anchor.diff:  (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))))))
  +                                                  (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))
  
positive.code: (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))
      (declare (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)
  
negative.code:    :after (reverse (remove-if-not #'after-reply-p replies))))
  
  (defun find-applicable-replies (message args &key (errorp t))
    (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
  