anchor.diff:        (let ((questions (read inf nil)))
           (setf (questions-of module)
                 (make-array (length questions)
  -                          :initial-contents questions
                             :adjustable t
  -                          :fill-pointer t)))))
  -  (with-open-file (inf (orcabot-path "data/trivia-scores.lisp")
  -                       :direction :input
  -                       :if-does-not-exist nil)
  -    (clrhash (scores-of module))
  -    (when inf
  -      (loop for tuple = (read inf nil)
  -         while tuple
  -         do (setf (gethash (first tuple)
  -                           (scores-of module))
  -                  (second tuple))))))
  +                          :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 (coerce (questions-of module) 'list) :stream ouf)
  +
  +    (write (map 'list 'serialize-trivia-question (questions-of module))
  +           :stream ouf)
       (terpri ouf)))
  -
  -(defun save-trivia-scores (module)
  -  (with-open-file (ouf (orcabot-path "data/trivia-scores.lisp")
  -                       :direction :output
  -                       :if-exists :supersede
  -                       :if-does-not-exist :create)
  -    (maphash (lambda (key val)
  -               (write (list key val) :stream ouf)
  -               (terpri))
  -             (scores-of module))))
  -
  -(defun populate-trivia-queue (module)
  -  (let* ((count (length (questions-of module))))
  -    (setf (queue-of module) (make-random-list count count))))
  -
  -(defun pop-trivia-question (module)
  -  (unless (queue-of module)
  -    (populate-trivia-queue module))
  -  (pop (queue-of module)))
  -
  -(defun channel-trivia-question (module channel)
  -  (assoc channel (channel-questions-of module) :test #'string-equal))
  -
  -(defun channel-question-expired (module channel)
  -  (let ((current-q (channel-trivia-question module channel)))
  -    (or (null current-q)
  -        (> (- (get-universal-time) (second current-q)) 60))))
  -
  -(defun deactivate-channel-question (module channel)
  -  (setf (channel-questions-of module)
  -        (delete (channel-trivia-question module channel)
  -                (channel-questions-of module))))
  -
  -(defun ask-new-trivia-question (module channel)
  -  (deactivate-channel-question module channel)
  -
  -  (let* ((q-idx (pop-trivia-question module))
  -         (new-q (aref (questions-of module) q-idx)))
  -    (push (list channel (get-universal-time) (1+ q-idx) new-q)
  -          (channel-questions-of module))
  -    (format nil "~a. ~a" (1+ q-idx) (first new-q))))
  -
  -(defun normalize-guess (guess)
  -  (string-trim
  -   '(#\space)
  -   (ppcre:regex-replace
  -    "^(the|a|an) "
  -    (ppcre:regex-replace-all
  -     "\\s+"
  -     (ppcre:regex-replace-all "[^\\s\\w]" (string-downcase guess) " ")
  -     " ")
  -    "")))
  -
  -(defun guess-trivia-answer (module channel user guess)
  -  (let ((current-q (assoc channel
  -                          (channel-questions-of module)
  -                          :test #'string=))
  -        (normal-guess (normalize-guess guess)))
  -    (when (find normal-guess (rest (fourth current-q)) :test #'string=)
  -      (incf (gethash user (scores-of module) 0))
  -      (save-trivia-scores module)
  -      (deactivate-channel-question module channel)
  -      t)))
   
   (defun add-trivia-question (module question)
     (let* ((split-q (ppcre:split "\\s*([.?])\\s*" question :with-registers-p t))
  
positive.code:        (cond
           ((channel-question-expired module channel)
            (when current-q
              (reply-to message "The answer was: ~a" (second (fourth 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)))))))
      ((string-equal "--score" (first args))
       (let ((nick (or (second args)
                       (source message))))
         (reply-to message "~a has answered ~a trivia question~:p correctly."
                   nick (gethash nick (scores-of module) 0))))
      ((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))
                           #'> :key #'second)))
         (loop
            for tuple in scores
  
negative.code: 
  (defmodule trivia trivia-module ("trivia" "addtrivia" "deltrivia")
    (questions :accessor questions-of
               :documentation "All the questions/answers available for asking, adjustable vector of (ID QUESTION ANSWERS*)")
    (queue :accessor queue-of :documentation "A queue of the questions to be asked")
    (scores :accessor scores-of :initform nil
            :documentation "Alist of correct answers of all the users who have played, (USER ID ID ID...)")
    (channel-questions :accessor channel-questions-of :initform nil
                     :documentation "Last asked question on a channel, list of (CHANNEL TIME QUESTION"))
  
  ;;; Trivia questions
  (defclass trivia-question ()
    ((id :accessor id-of :initarg :id)
     (text :accessor text-of :initarg :text)
     (answers :accessor answers-of :initarg :answers)))
  
  (defun deserialize-trivia-question (form)
    (if (numberp (first form))
        (make-instance 'trivia-question
                       :id (first form)
                       :text (second form)
                       :answers (cddr form))
        (make-instance 'trivia-question
                       :id nil
                       :text (first form)
                       :answers (cdr form))))
  
  (defun serialize-trivia-question (question)
    `(,(id-of question)
       ,(text-of question)
       ,@(answers-of question)))
  
  (defun load-trivia-questions (module)
    (with-open-file (inf (orcabot-path "data/trivia-questions.lisp")
                         :direction :input
                         :if-does-not-exist nil)
  