anchor.diff:  ;; where (rest-of-predicate) is (noun-phrase-1 preposition noun-phrase-2)
   ;; where (noun-phrase) is (noun (modifiers))
   ;;
  -
   (defun parse-string (string)
     "Parses a STRING that was entered by PLAYER and returns an Abstract Syntax Tree"
     (parse-sentence (string->token-list string)))
   
  -(defun preparse-adverbs (token-list) ;This is the worst way to handle this shit. Ever. Temporary. Very.
  +(defun preparse-adverbs (token-list) 
     "Yoinks all the adverbs it recognizes out of a list.
   MULTIPLE RETURN VALUES: The first adv it finds, and a token-list purified of this evil."
  +  ;; This is the worst way to handle this shit. Ever. Temporary. Very.
     (if (> (length token-list) 1)
         (let ((adverb (find-if #'adverb-p token-list)))
   	(if adverb
  
positive.code: 		      (list verb rest-of-predicate adverbs nil))))))
  	  (t
  	   (let ((fail-verb (car token-list)))
  	     ;; NOTE: Should this really return this value? Maybe it should raise a condition?
  	     (if fail-verb
  		 (format nil "Unknown verb: '~a'" fail-verb)
  		 (format nil "Invalid input")))))))
  
  (defun parse-rest-of-predicate (token-list)
    "Generates the REST-OF-PREDICATE list."
  
negative.code:   (gethash string *adverbs*))
       
  ;; Util
  
  (define-condition unknown-verb-error (error)
    ((text :initarg :text :reader text)
     (verb :initarg :verb :reader verb))
    (:documentation "Signaled whenever an unknown verb is encountered.")
    (:report (lambda (condition stream)
  	     (format stream "Tried to parse an unknown verb: ~A" (verb condition)))))
  
  (define-condition parser-error (error)
    ((text :initarg :text :reader text))
    (:documentation "Condition signaled whenever some generic parsing error happens.")
    (:report "Parser probably got some garbage input, or an empty string."))
  
  (defun test-the-parser ()
    "Runs a loop that asks for player input and returns whatever gets parsed. Quits on 'quit'."
    (let ((current-input (prompt-user)))
  