anchor.diff:                                    (:ordinality . ,ordinality)
                                     (:owns . ,owns)))
                                token-list)))
  -                  (t (error 'parser-error :text "I'm so confused. Why am I here? Who are you?")))))))))
  +                  (t (when it (push it token-list))
  +                     (return-from parse-noun-phrase (values nil token-list))))))))))
   
   ;;;
   ;;; Util
  
positive.code:     (loop
         (case state
           (:pronoun
            (let ((token (pop token-list)))
              (if (pronounp token)
                  (return-from parse-noun-phrase
                    (values `(:noun-phrase
                              . ((:pronoun . ,token)))
                            token-list))
                  (setf token-list (cons token token-list)
                        state :article))))
           (:article
            (let ((token (pop token-list)))
              (cond ((null token)
                     (error 'parser-error :text "What? All done?"))
                    ((articlep token)
                     (setf state :numerical))
                    (t
                     (push token token-list)
                     (setf state :numerical)))))
           (:numerical
            (let ((token (pop token-list)))
              (cond ((null token)
                     (error 'parser-error :text "Looking for a number, got nothing at all!"))
                    ((cardinal-number-p token)
                     (setf amount (extract-number token)
                           state :adjective))
                    ((ordinal-number-p token)
                     (setf ordinality (extract-number token)
                           state :adjective))
                    (t
                     (push token token-list)
                     (setf state :adjective)))))
           (:adjective
            ;; punting on adjectives for now.
            (setf state :noun))
           (:noun
            ;; Punting on possessives for now, too.
            (let ((token (pop token-list)))
              (cond ((null token)
                     (error 'parser-error :text "I NEEDED A NOUN HERE!"))
                    ((not (or (adverbp token)
                              (prepositionp token)
                              (chat-string-p token)))
                     (setf noun token)
                     (return-from parse-noun-phrase
                       (values `(:noun-phrase
                                 . ((:noun . ,noun)
  
negative.code:         (when (prepositionp (car token-list))
            (setf prep2 (pop token-list)))
          (multiple-value-setq (ind-obj token-list) (parse-noun-group token-list))
          (values `((:direct-object
                     . (:prepositional-phrase
                        . ((:preposition . ,prep1)
                           (:object . ,dir-obj))))
                    (:indirect-object
                     . (:prepositional-phrase
                        . ((:preposition . ,prep2)
                           (:object . ,ind-obj)))))
                  adverb
                  token-list))))
  
  (defun parse-noun-group (token-list)
    "Parses a TOKEN-LIST into a LIST representing a NOUN GROUP (multiple noun
  