anchor.diff:                  (loop
                      for curr-sheep in curr-sheep-list
                      for hierarchy-position below (length curr-sheep-list)
  -                   do (dolist (role (sheep-direct-roles curr-sheep))
  +                   do (dolist (role (%sheep-roles curr-sheep))
                           (when (and (eq message (role-reply role))
                                      (= index (the fixnum (role-position role))))
                             (let ((curr-reply (role-reply role)))
  
positive.code:   (declare (message message) (list args))
    (let (;; This doesn't seem to be expensive at all..
           (relevant-args-length (the fixnum (arg-info-number-required (message-arg-info message))))
           ;; If I can avoid calling fetch-memo-vector-entry for singly-dispatched readers, that
           ;; would be -lovely-. Not sure how to do that yet, though.
          )
      (when (< (length args) relevant-args-length)
  
negative.code:           (create-reply-cache message (%find-applicable-replies
                                            message relevant-args
                                            :errorp errorp)))
          (let ((memo-entry (fetch-dispatch-cache-entry args message relevant-args-length)))
            (or memo-entry
                memo-entry
                (let* ((relevant-args (subseq args 0 relevant-args-length))
  