anchor.diff:                                             (db (result-id offer) :by))))
             collect (result-id offer))))
   
  +(defun reject-matching-offer (request-id offer-id)
  +  (let* ((request (db request-id))
  +         (offer (db offer-id))
  +         (requested-by (getf request :by))
  +         (offered-by (getf offer :by)))
  +    (if (or (find *userid* (list offered-by requested-by))
  +            (getf *user* :matchmaker))
  +      (progn
  +        (unindex-inventory-match request-id requested-by offer-id offered-by)
  +        (amodify-db request-id :hidden-matching-offers (pushnew offer-id it)
  +                               :matching-offers (remove offer-id it)))
  +      (permission-denied))))
  +
  +(defun unindex-inventory-match (request-id requested-by offer-id offered-by)
  +  (with-locked-hash-table (*offers-with-matching-requests-index*)
  +    (asetf (gethash offer-id *offers-with-matching-requests-index*)
  +           (remove request-id it)))
  +
  +  (with-locked-hash-table (*account-inventory-matches-index*)
  +    (asetf (getf (gethash offered-by *account-inventory-matches-index*)
  +                 :requests)
  +           (remove (cons request-id offer-id) it :test #'equal))
  +    (asetf (getf (gethash requested-by
  +                          *account-inventory-matches-index*)
  +                 :offers)
  +           (remove (cons offer-id request-id) it :test #'equal))))
  +
   (defun unmatch-request-matches (request-id requested-by offers-to-unmatch)
     (dolist (offer-id offers-to-unmatch)
       (let* ((offer (db offer-id))
              (offered-by (getf offer :by)))
  -      (with-locked-hash-table (*offers-with-matching-requests-index*)
  -        (asetf (gethash offer-id *offers-with-matching-requests-index*)
  -               (remove request-id it)))
  -
  -      (with-locked-hash-table (*account-inventory-matches-index*)
  -        (asetf (getf (gethash offered-by *account-inventory-matches-index*)
  -                     :requests)
  -               (remove (cons request-id offer-id) it :test #'equal))
  -        (asetf (getf (gethash requested-by
  -                              *account-inventory-matches-index*)
  -                     :offers)
  -               (remove (cons offer-id request-id) it :test #'equal))))))
  -
  -(defun update-matchmaker-request-data (request-id &key data matchmaker prior-matching-offers rejected-offers)
  +      (unindex-inventory-match request-id requested-by offer-id offered-by))))
  +
  +(defun update-matchmaker-request-data (request-id &key data matchmaker)
     (let* ((request (or data (db request-id)))
  -         (prior-matching-offers (or prior-matching-offers
  -                                    (getf request :matching-offers)))
  -         (rejected-offers (or rejected-offers
  -                              (getf request :hidden-matching-offers)))
  +         (prior-matching-offers (getf request :matching-offers))
  +         (rejected-offers (getf request :hidden-matching-offers))
            (requested-by (getf request :by))
            (matchmaker (or matchmaker
                            (gethash request-id *matchmaker-requests*)))
  
positive.code:                 (find offer-id (getf request :matching-offers)))
          (amodify-db request-id :hidden-matching-offers (remove offer-id it)
                                 :matching-offers (remove offer-id it))
          (with-locked-hash-table (*account-inventory-matches-index*)
            (asetf (getf (gethash requested-by
                                  *account-inventory-matches-index*)
                         :offers)
                   (remove (cons offer-id request-id) it :test #'equal))
            (asetf (getf (gethash offered-by
                                  *account-inventory-matches-index*)
                         :requests)
                   (remove (cons request-id offer-id) it :test #'equal)))))))
  
  (defun update-matchmaker-offer-data (offer-id)
    (let ((offered-by (db offer-id :by))
  
negative.code:                  (pushnew (cons request-id offer-id) it :test #'equal)))))
  
      (amodify-db request-id
                  :matching-offers new-useful-offers)))
  
  (defun unmatch-offer-matches (offer-id offered-by requests-to-unmatch)
    (dolist (request-id requests-to-unmatch)
  