anchor.diff:  
   (defun cmd-def (client target line)
     (let* ((word (string-downcase (nth-word 1 line)))
  -         (definitions (dictionary-read word)))
  +         (definitions (definitions-read word)))
       (if (and word definitions)
           (loop :for def :in definitions
                 :for n :upfrom 1
  
positive.code:         (unless (gethash word hash)
            (remhash word hash))))))
  
  (defvar *dictionary-pathname*
    (merge-pathnames #p "eval-bot-dictionary" (user-homedir-pathname)))
  
  (defun dictionary-load ()
    (with-standard-io-syntax
      (let ((*read-eval* nil))
        (handler-case
            (with-open-file (file *dictionary-pathname*
                                  :direction :input
                                  :if-does-not-exist :error)
              (bt:with-lock-held ((lock *dictionary*))
                (loop :for expr := (read file nil)
                      :while expr
                      :do (setf (gethash (first expr) (hash *dictionary*))
                                (rest expr))))
              (send :terminal "Dictionary loaded."))
  
          (file-error (c)
            (send :terminal (format nil "~A: ~A" (type-of c) c))
            (send :terminal "Dictionary load failed."))))))
  
  (defun dictionary-save ()
    (with-standard-io-syntax
      (handler-case
          (with-open-file (file *dictionary-pathname*
                                :direction :output
                                :if-exists :rename)
            (format file ";;; Eval-bot dictionary~%")
            (bt:with-lock-held ((lock *dictionary*))
              (loop :for key :being :each :hash-key :in (hash *dictionary*)
                    :using (hash-value value)
                    :do (write (cons key value) :stream file)
                    (terpri file))
              (setf (changed *dictionary*) nil)))
  
        (file-error (c)
          (send :terminal (format nil "~A: ~A" (type-of c) c))
          (send :terminal "Dictionary save failed.")))))
  
  ;;; General maintainer
  
  
negative.code:                   (append old (list definition)))
                changed t)))))
  
  (defun definitions-read (word)
    (bt:with-lock-held ((lock *definitions*))
      (gethash (string-downcase word) (hash *definitions*))))
  
  (defun definitions-delete (word nth)
    (setf word (string-downcase word))
    (with-slots (lock hash changed) *definitions*
      (bt:with-lock-held (lock)
        (let ((old (gethash word hash)))
          (setf (gethash word hash) (remove-nth nth old)
  