anchor.diff:    "trivia - ask a new trivia question"
     (cond
       ((null args)
  -     (let* ((channel (first (arguments message)))
  -            (current-q (channel-trivia-question module channel)))
  -       (cond
  -         ((channel-question-expired module channel)
  -          (when current-q
  -            (reply-to message "The answer was: ~a" (first (answers-of (question-of current-q)))))
  -          (reply-to message "~a" (ask-new-trivia-question module channel)))
  -         (t
  -          (reply-to message "~a. ~a" (id-of (question-of current-q)) (text-of (question-of current-q)))))))
  +     (reply-to message "~a"
  +               (with-output-to-string (str)
  +                 (request-new-question module
  +                                       (first (arguments message))
  +                                       str))))
       ((string-equal "--score" (first args))
  -     (let ((nick (normalize-nick (or (second args)
  -                                     (source message)))))
  -       (reply-to message "~a has answered ~a trivia question~:p correctly."
  -                 nick (user-trivia-score module nick))))
  +     (reply-to message "~a"
  +               (with-output-to-string (str)
  +                 (display-trivia-score module
  +                                       (or (second args)
  +                                           (source message))
  +                                       str))))
       ((string-equal "--top" (first args))
  -     (let ((scores (sort (loop for tuple in (scores-of module)
  -                            as nick = (first tuple)
  -                            as score = (length (rest tuple))
  -                            collect (list nick score))
  -                         #'> :key #'second)))
  -       (loop
  -          for tuple in scores
  -          for place from 1 upto 5
  -          do (reply-to message "~a. ~10a (~a)" place (first tuple)
  -                       (second tuple)))))
  +     (reply-to message "~a"
  +               (with-output-to-string (str)
  +                 (top-trivia-scores module str))))
       (t
        (reply-to message "~~trivia                  - request a trivia question")
        (reply-to message "~~trivia --score [<nick>] - get score of user")
  
positive.code:                             collect (if punct
                                          (concatenate 'string text punct)
                                          text)))
           (new-question (list* (first question-parts)
                                (mapcar 'normalize-guess (rest question-parts)))))
      ;; insert at end of database
      (vector-push-extend new-question (questions-of module)))
    (save-trivia-questions module)
    (length (questions-of module)))
  
  (defun delete-trivia-question (module q-num)
    (let* ((idx (1- q-num))
  
negative.code:   ((id :accessor id-of :initarg :id)
     (text :accessor text-of :initarg :text)
     (answers :accessor answers-of :initarg :answers)))
  
  (defmethod print-object ((object trivia-question)
                           stream)
    (print-unreadable-object (object stream :type t)
      (format stream "~d. ~s" (id-of object)
              (text-of object))))
  
  (defun deserialize-trivia-question (form)
    (if (numberp (first form))
  