anchor.diff:          (unless (gethash word hash)
             (remhash word hash))))))
   
  -(defvar *dictionary-pathname*
  -  (merge-pathnames #p "eval-bot-dictionary" (user-homedir-pathname)))
  -
  -(defun dictionary-load ()
  +(defvar *definitions-pathname*
  +  (merge-pathnames #p "definitions.lisp" (user-homedir-pathname)))
  +
  +(defun definitions-load ()
     (with-standard-io-syntax
       (let ((*read-eval* nil))
         (handler-case
  -          (with-open-file (file *dictionary-pathname*
  +          (with-open-file (file *definitions-pathname*
                                   :direction :input
                                   :if-does-not-exist :error)
  -            (bt:with-lock-held ((lock *dictionary*))
  +            (bt:with-lock-held ((lock *definitions*))
                 (loop :for expr := (read file nil)
                       :while expr
  -                    :do (setf (gethash (first expr) (hash *dictionary*))
  +                    :do (setf (gethash (first expr) (hash *definitions*))
                                 (rest expr))))
  -            (send :terminal "Dictionary loaded."))
  +            (send :terminal "Definitions loaded."))
   
           (file-error (c)
             (send :terminal (format nil "~A: ~A" (type-of c) c))
  -          (send :terminal "Dictionary load failed."))))))
  -
  -(defun dictionary-save ()
  +          (send :terminal "Load definitions failed."))))))
  +
  +(defun definitions-save ()
     (with-standard-io-syntax
       (handler-case
  -        (with-open-file (file *dictionary-pathname*
  +        (with-open-file (file *definitions-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*)
  +          (format file ";;; Eval-bot definitions~%")
  +          (bt:with-lock-held ((lock *definitions*))
  +            (loop :for key :being :each :hash-key :in (hash *definitions*)
                     :using (hash-value value)
                     :do (write (cons key value) :stream file)
                     (terpri file))
  -            (setf (changed *dictionary*) nil)))
  +            (setf (changed *definitions*) nil))
  +          (send :terminal "Definitions saved."))
   
         (file-error (c)
           (send :terminal (format nil "~A: ~A" (type-of c) c))
  -        (send :terminal "Dictionary save failed.")))))
  +        (send :terminal "Save definitions failed.")))))
   
   ;;; General maintainer
   
  
positive.code: 
  (defun cmd-def (client target line)
    (let* ((word (string-downcase (nth-word 1 line)))
           (definitions (dictionary-read word)))
      (if (and word definitions)
          (loop :for def :in definitions
                :for n :upfrom 1
  
negative.code:                     (1- (parse-integer sub))
                      nil)))
           (word1 (nth-word 1 line))
           (def (definitions-read word1))
           msg)
  
      (cond ((null def)
             (setf msg (irc-fmt "No definitions for \"~A\"." word1)))
            ((or (and (not nth) (= (length def) 1))
                 (and nth (<= 0 nth (1- (length def)))))
             (definitions-delete word1 (or nth 0))
             (setf msg (if (definitions-read word1)
                           (irc-fmt
                            "Deleted definition ~D from \"~A\" (~D left)."
                            (1+ nth) word1 (length (definitions-read word1)))
                           (irc-fmt "Deleted the last definition from \"~A\"."
                                    word1))))
            ((and (not nth)
  