anchor.diff:  (defun keybind-find-from-command (name)
     (let ((name (intern (string-upcase name) :lem)))
       (dolist (keymap *keymaps*)
  -      (dolist (elt (keymap-alist keymap))
  -        (when (eq name (cdr elt))
  -          (return-from
  -           keybind-find-from-command
  -           (list (car elt) (keymap-name keymap))))))))
  +      (maphash (lambda (key val)
  +                 (when (eq name val)
  +                   (return-from keybind-find-from-command
  +                     (list key (keymap-name keymap)))))
  +               (keymap-table keymap)))))
   
   (defun key-undef-hook (keymap keys)
     (when (keymap-undef-hook keymap)
  
positive.code:       keys)))
  
  (defun keymap-find-command (keymap keys)
    (let ((cmd (cdr
                (assoc (keys-to-keystr keys)
                  (keymap-alist keymap)
                  :test 'equal))))
      (or cmd
        (let ((keymap (keymap-parent keymap)))
          (when keymap
  
negative.code:   name
    undef-hook
    parent
    table)
  
  (defun make-keymap (name &optional undef-hook parent)
    (let ((keymap (make-keymap-internal
                   :name name
                   :undef-hook undef-hook
                   :parent parent
                   :table (make-hash-table :test 'equal))))
      (push keymap *keymaps*)
      keymap))
  
  (defvar *global-keymap* (make-keymap "global" 'undefined-key))
  
  (defun define-key (keymap kbd cmd-name)
    (setf (gethash kbd (keymap-table keymap))
          cmd-name))
  
  (defun keys-to-keystr (keys)
    (apply 'concatenate 'string
  