anchor.diff:  
   TODO: Determine  in what  time zone  we should  computer this  for legal
   reasons, eg, COPPA."
  +  (check-type date-of-birth local-time:timestamp)
  +  (check-type reference-date local-time:timestamp)
  +  (unless (local-time:timestamp< date-of-birth reference-date)
  +    (return-from legal-age 0))
     (multiple-value-bind (msec sec min hour day month year)
  -      (local-time:decode-timestamp (local-time:now))
  +      (local-time:decode-timestamp reference-date)
       (declare (ignore msec sec min hour))
  -    (multiple-value-bind (_1 _2 _3 _4
  -                             day-of-birth month-of-birth year-of-birth)
  +    (multiple-value-bind (msec sec min hour
  +                               day-of-birth month-of-birth year-of-birth)
           (local-time:decode-timestamp date-of-birth)
  -      (declare (ignore _1 _2 _3 _4))
  +      (declare (ignore msec sec min hour))
         (let ((had-birthday-p (or (< month-of-birth month)
                                   (and (= month-of-birth month)
                                        (<= day-of-birth day)))))
  -        (+ (- year year-of-birth 1)
  +        (+ (- year
  +              year-of-birth
  +              1)
              (if had-birthday-p 1 0))))))
  +
  +(eval-when (:compile-toplevel :execute :load-toplevel)
  +  ;; Promote the  DEFSTRUCT function to  a generic function that  we can
  +  ;; define a method AROUND.
  +  (let ((player-age-fn (symbol-function 'player-age)))
  +    (unless (typep player-age-fn 'generic-function)
  +      (fmakunbound 'player-age)
  +      (defgeneric player-age (player)
  +        (:documentation "Get the AGE of the PLAYER")
  +        (:method ((player player)) (funcall player-age-fn player))))))
   
   (defmethod player-age :around (player)
     "This  AROUND method  will define  the PLAYER's  age based  upon their
  
positive.code:     (player player)
      ((integer 1 *) (find-player-by-id player))
      (string (find-player-by-id (parse-integer player :radix 36)))))
  
negative.code:         player)
        (make-user-registration registrar id info)))
  
  (defun user-id<-registration (registrar id-string)
    (with-connection (:members)
      (datafly:retrieve-one-value
       (sxql:select (:id)
         (sxql:from :player-registrations)
         (sxql:where (:and (:equal :registrar (string registrar))
                           (:equal :id-string id-string)))))))
  
  (defmethod user-id<-registrar-id ((registrar symbol) (id string) &optional info)
    "The default handler  accepts any persistently unique  ID string and
  