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