anchor.diff:  
   (declaim (inline desired-vector-entry-p))
   (defun desired-vector-entry-p (args vector-entry relevant-args-length)
  -  (declare (fixnum relevant-args-length))
  -  (declare (list args))
  +  (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)
  
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: (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))
  