anchor.diff:      (gethash message message-table))
   
     (defun reset-message-ranks ()
  -    (maphash #'reset-rank message-table))
  +    (clrhash message-table))
     
     (defun reset-rank (key val)
       (declare (ignore key))
  
positive.code: ;;;
  
  (defun apply-message (selector args)
    (let ((function (message-function (find-most-specific-message selector args))))
     (apply function args)))
  
  (defun sheep-or-dolly (sheeple)
    (mapcar (lambda (sheep) 
  	    (if (not (sheep-p sheep))
  		=dolly=
  
negative.code:   ;; This shit is bugged to all hell and it's a huge, disgusting algorithm. Fix that shit.
    ;; taken almost verbatim from Slate's algorithm
    (let ((n (length args))
  	(most-specific-message nil))
      (loop 
         for arg in args
         for index upto (1- n)
         do (let ((curr-sheep-list (compute-sheep-hierarchy-list arg)))
  	    (loop 
  	       for curr-sheep in curr-sheep-list
  	       for hierarchy-position upto (1- (length curr-sheep-list))
  	       do (dolist (role (sheep-direct-roles curr-sheep))
  		    (when (and (eql selector (role-name role))
  				   (eql index (role-position role)))
  			  (let ((curr-message (message-pointer role)))
  			    (maybe-add-message-to-table curr-message)
  			    (setf (elt (message-rank curr-message) index) hierarchy-position)
  			    (when (fully-specified-p (message-rank curr-message)) 
  			      (when (or (not most-specific-message)
  					(< (calculate-rank-score (message-rank curr-message))
  					   (calculate-rank-score (message-rank most-specific-message))))
  				(setf most-specific-message curr-message)))))))))
  ;    (reset-message-ranks)
      most-specific-message))
  
  ;; Message table
  (let ((message-table (make-hash-table :test #'equal)))
  