anchor.diff:  (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))))))
  +                                                  (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))
  +    (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)
  
positive.code:    :after (reverse (remove-if-not #'after-reply-p replies))))
  
  (defun find-applicable-replies (message args &key (errorp t))
    (declare (message message))
    (declare (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
  
negative.code: 
  (declaim (inline desired-vector-entry-p))
  (defun desired-vector-entry-p (args vector-entry relevant-args-length)
    (declare (fixnum relevant-args-length) (list args))
    (when (vectorp vector-entry)
      (let ((vector-args (weak-pointer-value (vector-entry-args vector-entry))))
        (cond ((= 0 relevant-args-length)
  