anchor.diff:  
   (add-dependencies 'procedures
   		  '(instruction-ownership))
  -
  -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  -;;;
  -;;; Determine the predecessors of every instruction in a program.
  -
  -(defun compute-predecessors (program)
  -  (let ((*program* program))
  -    (map-instructions
  -     (lambda (instruction)
  -       (setf (predecessors instruction) '())))
  -    (map-instructions
  -     (lambda (instruction)
  -       (loop for successor in (successors instruction)
  -	     do (push instruction (predecessors successor)))))))
  -
  -(set-processor 'predecessors 'compute-predecessors)
  -	       
  -(add-dependencies 'predecessors
  -		  '(instruction-info))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  
positive.code: (set-processor 'basic-blocks 'compute-basic-blocks)
  
  (add-dependencies 'basic-blocks
  		  '(instruction-ownership
  		    predecessors))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  
negative.code: 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Depth-first pre-order and post-order traversal of a flowchart.
  
  (defun depth-first-pre-order (initial-instruction)
    (let ((table (make-hash-table :test #'eq))
  	(result '()))
      (labels ((traverse (instruction)
  	       (unless (gethash instruction table)
  		 (setf (gethash instruction table) t)
  		 (loop for succ in (successors instruction)
  		       do (traverse succ))
  		 (push instruction result))))
        (traverse initial-instruction))
      result))
  
  (defun depth-first-post-order (initial-instruction)
    (reverse (depth-first-pre-order initial-instruction)))
  
  (defun backward-depth-first-pre-order (initial-instruction)
    (let ((table (make-hash-table :test #'eq))
  	(result '()))
      (labels ((traverse (instruction)
  	       (unless (gethash instruction table)
  		 (setf (gethash instruction table) t)
  		 (loop for pred in (predecessors instruction)
  		       do (traverse pred))
  		 (push instruction result))))
        (traverse initial-instruction))
      result))
    
  (defun backward-depth-first-post-order (initial-instruction)
    (reverse (backward-depth-first-pre-order initial-instruction)))
  
  (defun kosaraju (initial-instruction)
    (let ((pre (depth-first-pre-order initial-instruction))
  	(table (make-hash-table :test #'eq))
  	(result '())
  	(temp '()))
      (labels ((traverse (instruction)
  	       (unless (gethash instruction table)
  		 (setf (gethash instruction table) t)
  		 (loop for pred in (predecessors instruction)
  		       do (traverse pred))
  		 (push instruction temp))))
        (loop until (null pre)
  	    for initial = (pop pre)
  	    unless (gethash initial table)
  	      do (setf temp '())
  		 (traverse initial)
  		 (push temp result))
        result)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  