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:                 for v-arg in vector-args
                  for arg in args
                  do (when (not (equal v-arg arg))
                       (return-from desired-vector-entry-p nil))))))))
  
  (defun fetch-memo-vector-entry (args message relevant-args-length)
    (let* ((memo-vector (message-memo-vector message))
           (orig-index (mod (the fixnum (sxhash (if (sheep-p (car args))
                                                    (car args)
                                                    (or (find-boxed-object (car args))
                                                        (box-type-of (car args))))))
                            (length memo-vector))))
      ;; I don't know how this could be any faster. My best choice is probably to avoid calling it.
      (declare (vector memo-vector) (fixnum orig-index))
      (let ((attempt (aref memo-vector orig-index)))
        (if (desired-vector-entry-p args attempt relevant-args-length)
            (vector-entry-msg-cache attempt)
            (progn
              (loop for entry across memo-vector
                 do (when (desired-vector-entry-p args entry relevant-args-length)
                      (return-from fetch-memo-vector-entry (vector-entry-msg-cache entry))))
              nil)))))
  
  (defun memoize-reply-dispatch (message args msg-list)
    (let ((msg-cache (create-reply-cache message msg-list))
          (maybe-index (mod (the fixnum (sxhash (if (sheep-p (car args))
                                                    (car args)
                                                    (or (find-boxed-object (car args))
                                                        (box-type-of (car args))))))
                            (length (the vector (message-memo-vector message))))))
      (add-entry-to-message msg-cache message args maybe-index)
      msg-cache))
  
  
negative.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-dispatch-cache-entry for singly-dispatched readers, that
           ;; would be -lovely-. Not sure how to do that yet, though.
          )
      (when (< (length args) relevant-args-length)
  