anchor.diff:         (cond
            ((channel-question-expired module channel)
             (when current-q
  -            (reply-to message "The answer was: ~a" (second (fourth 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"
  -                    (third current-q)
  -                    (first (fourth current-q)))))))
  +          (reply-to message "~a. ~a" (id-of (question-of current-q)) (text-of (question-of current-q)))))))
       ((string-equal "--score" (first args))
  -     (let ((nick (or (second args)
  -                     (source message))))
  +     (let ((nick (normalize-nick (or (second args)
  +                                     (source message)))))
          (reply-to message "~a has answered ~a trivia question~:p correctly."
  -                 nick (gethash nick (scores-of module) 0))))
  +                 nick (user-trivia-score module nick))))
       ((string-equal "--top" (first args))
  -     (let ((scores (sort (loop for nick being the hash-keys of (scores-of module)
  -                              as score = (gethash nick (scores-of module))
  -                              collect (list nick score))
  +     (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
  
positive.code: 
  (defmodule trivia trivia-module ("trivia" "addtrivia" "deltrivia")
    (questions :accessor questions-of
               :documentation "All the questions/answers available for asking, adjustable vector of (QUESTION ANSWERS*)")
    (queue :accessor queue-of :documentation "A queue of the questions to be asked")
    (scores :accessor scores-of :initform (make-hash-table :test 'equal)
            :documentation "Count of correct answers of all the users who have played")
    (channel-questions :accessor channel-questions-of :initform nil
                     :documentation "Last asked question on a channel, list of (CHANNEL TIME ID QUESTION"))
  
  (defmethod initialize-module ((module trivia-module) config)
    (load-trivia-data module)
    (populate-trivia-queue module))
  
  (defun load-trivia-data (module)
    (with-open-file (inf (orcabot-path "data/trivia-questions.lisp")
                         :direction :input
                         :if-does-not-exist nil)
  
negative.code:       (let ((questions (read inf nil)))
          (setf (questions-of module)
                (make-array (length questions)
                            :adjustable t
                            :fill-pointer t))
          (map-into (questions-of module) 'deserialize-trivia-question questions)
          (loop
             for question across (questions-of module)
             as idx from 1
             when (null (id-of question))
             do (setf (id-of question) idx))))))
  
  (defun save-trivia-questions (module)
    (with-open-file (ouf (orcabot-path "data/trivia-questions.lisp")
                         :direction :output
                         :if-exists :supersede
                         :if-does-not-exist :create)
  
      (write (map 'list 'serialize-trivia-question (questions-of module))
             :stream ouf)
      (terpri ouf)))
  
  (defun add-trivia-question (module question)
    (let* ((split-q (ppcre:split "\\s*([.?])\\s*" question :with-registers-p t))
  