anchor.diff:        (get-command cmd))))
   
   (defun abort-key-p (key)
  -  (eq 'keyboard-quit (lookup-keybind key)))
  +  (and (characterp key)
  +       (eq 'keyboard-quit (lookup-keybind key))))
  
positive.code: (defun kbd-p (x)
    (typep x 'kbd))
  
  (defun define-key (keymap key symbol)
    (check-type symbol symbol)
    (let ((kbd (typecase key
                 (symbol (loop :for (key1 . keymap1) :in (get key 'keybind)
                               :do (define-key keymap key1 symbol))
                         (return-from define-key))
                 (list (apply #'kbd key))
                 (string (kbd key))
                 (t key))))
      (unless (and (kbd-p kbd)
                   (every #'characterp (kbd-list kbd)))
        (error "define-key: ~s is illegal key" key))
      (pushnew (cons key keymap) (get symbol 'keybind) :test 'equal)
      (define-key-internal keymap kbd symbol)))
  
  (defun define-key-internal (keymap kbd symbol)
    (loop :with table := (keymap-table keymap)
          :for rest :on (kbd-list kbd)
          :for k := (car rest)
          :do (cond ((null (cdr rest))
                     (setf (gethash k table) symbol))
  
negative.code:                          (let ((new-table (make-hash-table :test 'equal)))
                             (setf (gethash k table) new-table)
                             (setf table new-table))))))))
  
  (defun parse-key (string)
    (labels ((f (string)
               (if (and (>= (length string) 2)
                        (eql (aref string 0) #\M)
                        (eql (aref string 1) #\-))
                   (cons (keyname->keychar "escape") (f (subseq string 2)))
                   (list (keyname->keychar string)))))
      (mapcan #'(lambda (string)
                  (if (and (< 4 (length string))
                           (string= string "C-M-" :end1 4))
                      (f (concatenate 'string
                                      "M-C-" (subseq string 4)))
                      (f string)))
              (uiop:split-string string :separator " "))))
  
  (defun kbd-to-string (key)
    (format nil "~{~A~^~}"
  