anchor.diff:    (do ((tail replies (cdr tail)))
         ((null tail) replies)
       (declare (list tail))
  -    (setf (car tail) (reply-container-reply (car tail)))))
  +    (setf (car tail) (unbox-ranked-reply (car tail)))))
   
  -(defun calculate-rank-score (rank)
  +(defun score-ranked-reply (ranked-reply)
     ;; All hell breaks loose if you don't give this a simple-vector
  -  (declare (simple-vector rank) (optimize speed (safety 0)))
  -  (loop for i fixnum downfrom (1- (length rank))
  -     for elt = (svref rank i) with total fixnum = 0
  +  (declare (ranked-reply ranked-reply) (optimize speed (safety 0)))
  +  (loop for i fixnum downfrom (1- (length ranked-reply))
  +     for elt = (svref ranked-reply i) with total fixnum = 0
  +     when (zerop i) return total
        unless (null elt) do
  -       (setf total (the fixnum (+ total (the fixnum elt))))
  -     when (zerop i) return total))
  +       (setf total (the fixnum (+ total (the fixnum elt))))))
   
  -(defun fully-specified-p (rank)
  +(defun fully-specified-p (ranked-reply)
     ;; Same here, and all the elements better be (or fixnum null)
  -  (declare (simple-vector rank) (optimize speed (safety 0)))
  -  (loop for i fixnum downfrom (1- (length rank))
  -     unless (svref rank i) return nil
  -     when (zerop i) return t))
  +  (declare (ranked-reply ranked-reply) (optimize speed (safety 0)))
  +  (loop for i fixnum downfrom (1- (length ranked-reply))
  +     when (zerop i) return t
  +     unless (svref ranked-reply i) return nil))
   
   (defun sort-applicable-replies (reply-list)
     ;; Most lisps compile this as a tail call, so this function ends up being a
     ;; macro around SORT, and there's no harm in the (safety 0)
     (declare (optimize speed (safety 0)) (list reply-list))
  -  (sort reply-list #'< :key (fun (calculate-rank-score (reply-container-rank _)))))
  +  (sort reply-list #'< :key 'score-ranked-reply))
   
   (defun apply-message (message args)
     (let ((relevant-args-length (arg-info-number-required (message-arg-info message))))
  
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
  