anchor.diff:  
   (in-package :next)
   
  -(defvar *key-sequence-stack* ()
  +(defvar *key-chord-stack* ()
     "A stack that keeps track of the key chords a user has inputted")
   
   ;; A struct used to describe a key-chord
  -(defstruct key
  -  character-code
  -  control-modifier
  -  meta-modifier
  -  super-modifier)
  +(defstruct key-chord
  +  key-code
  +  key-string
  +  modifiers)
   
   (defvar *character-conversion-table* (make-hash-table :test 'equalp))
   (setf (gethash "SPACE" *character-conversion-table*) (char-code #\Space))
  
positive.code: (setf (gethash "HYPHEN" *character-conversion-table*) (char-code #\-))
  (setf (gethash "ESCAPE" *character-conversion-table*) (char-code #\Esc))
  
  (defun get-char-code (char-string)
    ;; Take a string that represents a character and convert it into
    ;; key code representing it.
    ;; If the char-string does not represent a single character; returns nil
    (let ((character-code (gethash char-string *character-conversion-table* nil))
  	(single-char? (= (length char-string) 1)))
      (cond
        (character-code character-code)
        (single-char? (char-code (char char-string 0)))
        (t ()))))
  
  (defun push-key-chord (control-modifier meta-modifier super-modifier key-code)
    ;; 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)))
      (when control-modifier
        (setf (key-control-modifier key-chord) t))
      (when meta-modifier
        (setf (key-meta-modifier key-chord) t))
      (when super-modifier
        (setf (key-super-modifier key-chord) t))
      (setf (key-character-code key-chord) key-code)
      (push key-chord *key-sequence-stack*))
    (if (consume-key-sequence) 1 0))
  
  (defun consume-key-sequence ()
  
negative.code: 		   *global-map*
  		   (keymap (mode (active-buffer *interface*))))))
      (dolist (map key-maps)
        (when (gethash *key-chord-stack* map)
  	;; If not prefix key, consume
  	(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-chord-stack* ())))
  
  (defun define-key (mode-map key-sequence function)
    ;; A sequence of "C-x" "C-s" "C-a" will be broken
  