anchor.diff:    (unless nick (setf nick (nick event)))
     (unless server (setf server (name (server event))))
     (pushnew (format NIL "~a/~a" (string-upcase server) (string-upcase nick))
  -           (whitelist module) :test #'string-equal)
  +           (uc:config-tree :whitelist) :test #'string-equal)
     (respond event "User ~a whitelisted!" nick))
   
   (define-command (rules blacklist) (&optional nick server) (:authorization T :documentation "Remove a user from the whitelist.")
     (unless nick (setf nick (nick event)))
     (unless server (setf server (name (server event))))
  -  (setf (whitelist module)
  +  (setf (uc:config-tree :whitelist)
           (delete (format NIL "~a/~a" (string-upcase server) (string-upcase nick))
  -                (whitelist module) :test #'string-equal))
  +                (uc:config-tree :whitelist) :test #'string-equal))
     (respond event "User ~a removed from the whitelist!" nick))
  
positive.code:    (%active-on :initarg :active-on :initform () :accessor active-on))
    (:documentation "Class for containing rulesets."))
  
  (defmethod print-object ((rule rule) stream)
    (print-unreadable-object (rule stream :type T)
      (format stream "~a \"~a\"" (rule-type rule) (regex rule))))
  
  (defmethod yason:encode ((rule rule) &optional (stream *standard-output*))
    (yason:with-output (stream)
      (yason:with-object ()
        (yason:encode-object-element "regex" (regex rule))
        (yason:encode-object-element "type" (string-upcase (rule-type rule)))
        (yason:encode-object-element "probation" (probation rule))
        (yason:encode-object-element "breach-msg" (breach-msg rule))
        (yason:encode-object-element "apology-msg" (apology-msg rule))
        (yason:encode-object-element "punish-msg" (punish-msg rule))
        (yason:encode-object-element "active-on" (active-on rule)))))
  
  (defmethod start ((rules rules))
    (with-open-file (stream *save-file* :if-does-not-exist NIL)
      (when stream
        (let ((data (yason:parse stream)))
          (loop for name being the hash-key of data
             for object being the hash-value of data
             do (setf (gethash name (rules rules))
                      (make-instance
                       'rule :name name
                       :regex (gethash "regex" object)
                       :type (find-symbol (gethash "type" object) :KEYWORD)
                       :probation (gethash "probation" object)
                       :breach-msg (gethash "breach-msg" object)
                       :apology-msg (gethash "apology-msg" object)
                       :punish-msg (gethash "punish-msg" object)
                       :active-on (gethash "active-on" object))))
          (v:info :rules "Loaded ~d rules." (hash-table-count data)))))
    (setf (whitelist rules) (config-tree :rules :whitelist)))
  
  (defmethod stop ((rules rules))
    (with-open-file (stream *save-file* :direction :output :if-exists :supersede :if-does-not-exist :create)
      (yason:encode (rules rules) stream)
      (v:info :rules "Saved ~d rules." (hash-table-count (rules rules))))
    (setf (config-tree :rules :whitelist) (whitelist rules)))
  
  (defun rule-format (event rule probation-count message)
    (format-message event message
                    (cons "\\$RULE\\$" (name rule))
                    (cons "\\$COUNT\\$" (format NIL "~a" probation-count))))
  
  
  (defparameter *apology-regex* (cl-ppcre:create-scanner "^(Colleen:\\s*)?(Sorry for|I apologize for|I'm sorry for)\\s+(breaking|violating|breaching|not minding|disregarding|saying)?\\s*(the\\s+)?(\\w+).*" :case-insensitive-mode T))
  (define-handler (privmsg-event event) ()
    (when (not (find (format NIL "~a/~a" (string-upcase (name (server event))) (string-upcase (nick event)))
                     (whitelist module) :test #'string-equal))
      (let ((name-format (format NIL "~a/~a" (name (server event)) (nick event)))
            (server-format (format NIL "~a/~a" (name (server event)) (channel event))))
        (unless (cl-ppcre:register-groups-bind (NIL NIL NIL NIL name) (*apology-regex* (message event))
                  (let ((rule (gethash name (rules module))))
                    (when (and rule (find server-format (active-on rule) :test #'string-equal))
                      (if (gethash name-format (users-on-probation rule))
                          (progn
  
negative.code:                         (respond event "~a: You don't need to apologize for ~a, silly!" (nick event) (name rule))))
                    T))
          
          (loop for rule being the hash-value of (uc:config-tree :rules)
             if (and (find server-format (active-on rule) :test #'string-equal)
                     (cl-ppcre:scan (regex rule) (string-downcase (message event))))
             do 
  