anchor.diff:  		   *global-map*
   		   (keymap (mode (active-buffer *interface*))))))
       (dolist (map key-maps)
  -      (when (gethash *key-sequence-stack* map)
  +      (when (gethash *key-chord-stack* map)
   	;; If not prefix key, consume
  -	(when (not (equalp (gethash *key-sequence-stack* map) "prefix"))
  -	  (funcall (gethash *key-sequence-stack* map))
  -	  (setf *key-sequence-stack* ()))
  +	(when (not (equalp (gethash *key-chord-stack* map) "prefix"))
  +	  (funcall (gethash *key-chord-stack* map))
  +	  (setf *key-chord-stack* ()))
   	(return-from consume-key-sequence t)))
       ;; If we made it to this point, key did not exist, return false,
       ;; allowing the key to be consumed by other widgets
  -    (setf *key-sequence-stack* ())))
  +    (setf *key-chord-stack* ())))
   
   (defun define-key (mode-map key-sequence function)
     ;; A sequence of "C-x" "C-s" "C-a" will be broken
  
positive.code:     ;; Iterate through all key chords (space delimited)
      (loop for key-chord-string in (cl-strings:split key-sequence-string " ")
  	  ;; Iterate through all keys in chord (hyphen delimited)
  	  do (let ((key-chord (make-key))
  		   (keys (cl-strings:split key-chord-string "-")))
  	       (loop for key-character-string in (butlast keys)
  		     do (cond
  			  ((equal "C" key-character-string)
  			   (setf (key-control-modifier key-chord) t))
  			  ((equal "M" key-character-string)
  			   (setf (key-meta-modifier key-chord) t))
  			  ((equal "S" key-character-string)
  			   (setf (key-super-modifier key-chord) t)))
  		     finally (setf (key-character-code key-chord)
  				   (get-char-code (first (last keys)))))
  	       (push key-chord key-sequence)))
      key-sequence))
  
negative.code: (setf (gethash "HYPHEN" *character-conversion-table*) (char-code #\-))
  (setf (gethash "ESCAPE" *character-conversion-table*) (char-code #\Esc))
  
  (defun push-key-chord (key-code key-string modifiers)
    ;; Adds a new chord to key-sequence
    ;; For example, it may add C-M-s or C-x
    ;; to a stack which will be consumed by
    ;; consume-key-sequence
    (let ((key-chord (make-key-chord
                      :key-code key-code
                      :key-string key-string
                      :modifiers (when (listp modifiers)
                                   (sort modifiers #'string-lessp)))))
      (print key-chord)
      (push key-chord *key-chord-stack*))
    (if (consume-key-sequence) 1 0))
  
  (defun consume-key-sequence ()
  