anchor.diff:                      (string (standard-case-symbol-name package-designator)))
                     error)))
   
  -;;; stamps: a REAL or a boolean where NIL=-infinity, T=+infinity
  +;;; timestamps: a REAL or a boolean where T=-infinity, NIL=+infinity
   (eval-when (#-lispworks :compile-toplevel :load-toplevel :execute)
  -  (deftype stamp () '(or real boolean)))
  -(with-upgradability ()
  -  (defun stamp< (x y)
  +  (deftype timestamp () '(or real boolean)))
  +(with-upgradability ()
  +  (defun timestamp< (x y)
       (etypecase x
  -      (null (and y t))
  -      ((eql t) nil)
  +      ((eql t) (not (eql y t)))
         (real (etypecase y
  -              (null nil)
  -              ((eql t) t)
  -              (real (< x y))))))
  -  (defun stamps< (list) (loop :for y :in list :for x = nil :then y :always (stamp< x y)))
  -  (defun stamp*< (&rest list) (stamps< list))
  -  (defun stamp<= (x y) (not (stamp< y x)))
  -  (defun earlier-stamp (x y) (if (stamp< x y) x y))
  -  (defun stamps-earliest (list) (reduce 'earlier-stamp list :initial-value t))
  -  (defun earliest-stamp (&rest list) (stamps-earliest list))
  -  (defun later-stamp (x y) (if (stamp< x y) y x))
  -  (defun stamps-latest (list) (reduce 'later-stamp list :initial-value nil))
  -  (defun latest-stamp (&rest list) (stamps-latest list))
  -  (define-modify-macro latest-stamp-f (&rest stamps) latest-stamp))
  +              ((eql t) nil)
  +              (real (< x y))
  +              (null t)))
  +      (null nil)))
  +  (defun timestamps< (list) (loop :for y :in list :for x = nil :then y :always (timestamp< x y)))
  +  (defun timestamp*< (&rest list) (timestamps< list))
  +  (defun timestamp<= (x y) (not (timestamp< y x)))
  +  (defun earlier-timestamp (x y) (if (timestamp< x y) x y))
  +  (defun timestamps-earliest (list) (reduce 'earlier-timestamp list :initial-value nil))
  +  (defun earliest-timestamp (&rest list) (timestamps-earliest list))
  +  (defun later-timestamp (x y) (if (timestamp< x y) y x))
  +  (defun timestamps-latest (list) (reduce 'later-timestamp list :initial-value t))
  +  (defun latest-timestamp (&rest list) (timestamps-latest list))
  +  (define-modify-macro latest-timestamp-f (&rest timestamps) latest-timestamp))
   
   
   ;;; Function designators
  
positive.code:             (if-let (dw ccl::*outstanding-deferred-warnings*)
                (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
                  (ccl::deferred-warnings.warnings mdw))))
      #+(or cmu scl)
      (when lisp::*in-compilation-unit*
        ;; Try to send nothing through the pipe if nothing needs to be accumulated
        `(,@(when c::*undefined-warnings*
  
negative.code:                   (setf ccl::*outstanding-deferred-warnings* (ccl::%defer-warnings t)))))
        (appendf (ccl::deferred-warnings.warnings dw)
                 (mapcar 'unreify-deferred-warning reified-deferred-warnings)))
      #+(or cmucl scl)
      (dolist (item reified-deferred-warnings)
        ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
        ;; For *undefined-warnings*, the adjustment is a list of initargs.
  