anchor.diff:  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   (in-package :sheeple)
   
  -(defstruct (reply-container (:type vector))
  -  reply rank)
  +(deftype ranked-reply ()
  +  'simple-vector)
   
  +(declaim (inline unbox-ranked-reply))
  +(defun unbox-ranked-reply (ranked-reply)
  +  (declare (ranked-reply ranked-reply) (optimize speed (safety 0)))
  +  (svref ranked-reply 0))
  +
  +(declaim (inline reply-specialized-length))
   (defun reply-specialized-length (reply)
     (count-required-parameters (reply-lambda-list reply)))
   
  -(defun contain-reply (reply)
  -  (make-reply-container
  -   :reply reply
  -   :rank (make-vector (reply-specialized-length reply))))
  +(defun box-reply (reply)                ; For lack of a better name
  +  (declare (reply reply) (optimize speed (safety 0)))
  +  (aprog1 (make-array (the fixnum (1+ (the fixnum (reply-specialized-length reply))))
  +                      :initial-element nil)
  +    (setf (svref it 0) reply)))
   
   (defun nunbox-replies (replies)
     "Unbox in-place each of the contained REPLIES."
  
positive.code:                   (declare (role role))
                    (when (and (eq message (role-message role))
                               (= index (the fixnum (role-position role))))
                      (let ((reply (role-reply role)) contained-reply)
                        (aif (find reply discovered-replies
                                   :key #'reply-container-reply :test #'eq)
                             (setf contained-reply it)
                             (push (setf contained-reply (contain-reply reply))
                                   discovered-replies))
                        (setf (elt (reply-container-rank contained-reply) index)
                              hierarchy-position)
                        (when (fully-specified-p (reply-container-rank contained-reply))
                          (unless (find reply contained-applicable-replies
                                        :key #'reply-container-reply :test #'eq)
                            (push contained-reply contained-applicable-replies)))))))
           finally
             (if contained-applicable-replies
                 (return (nunbox-replies (sort-applicable-replies contained-applicable-replies)))
                 (when errorp
                   (error 'no-applicable-replies :message (message-name message) :args args))))))
  
negative.code:             (compute-primary-erfun (cdr replies)))))
  
  (defun find-applicable-replies (message args &optional (errorp t))
    "Returns a sorted list of replies on MESSAGE for which appropriate roles
  are present in ARGS. If no such replies are found and ERRORP is true, a
  condition of type `no-applicable-replies' is signaled."
    (if (null args)
        (message-replies message)
        (loop with discovered-replies list and boxed-applicable-replies list
           for arg in args and index fixnum upfrom 0 do
             (loop
                for hierarchy-object in
  