anchor.diff:  
   (defun expand (acronym &optional (times 1 times-supplied-p))
     "Expands an acronym. If 'times' is provided, repeats expansion that many times and collects results into a list."
  -  ;; Remove all non-letter characters.
  -  ;(setf acronym (delete-if-not #'letterp acronym))
  -  (if times-supplied-p
  -      (loop repeat times collect (%expand acronym))
  -      (%expand acronym)))
  +  (cond (times-supplied-p ; Repeat takes the greatest prescedence
  +         (loop repeat times collect (%expand acronym)))
  +        ((every #'letterp acronym) ; Base case.
  +         (%expand acronym))
  +        ((every #'letterp (remove-if #'(lambda (p) (char-equal p #\Space)) acronym))
  +         ; Contains separate words into spaces
  +         (format nil "~{~a~^ and ~}"
  +                 (mapcar #'%expand (split-sequence #\Space acronym :remove-empty-subseqs t))))))
     
   ;;; Autoload the list
   (refresh-list)
  
positive.code:                (string (format out-string "~:[ ~;~]~a"
                                 (or firstp (not (letterp (aref part-of-speech 0))))
                                 part-of-speech))
                 (list
                  (format out-string "~:[ ~;~]~a"
                          firstp
                          (first part-of-speech))
                  (incf pointer))
                 (t
                  (format out-string "~:[ ~;~]~a"
                          firstp (random-word part-of-speech letter))
  
negative.code: (defun get-POS-template (acronym)
    "Returns an appropriate part-of-speech template for a given acronym, ready for use in build-backronym."
    ;; MAYBE: Do common (and irregular) substitutions here, like 2 → to, 4 → for
    (flet ((%get-POS-template (length)
             (random-elt (aref *master-structures-list* (1- length)))))
      (if (<= (length acronym) (length *master-structures-list*))
          ;; Randomly pick a template to use.
          (%get-POS-template (length acronym))
          ;; If the acronym is too long for any precomposed templates,
          ;; Join up existing templates with prepositions into a final template.
          (loop with length-of-structures-list = (length *master-structures-list*)
                with length-of-acronym         = (length acronym)
                for i                          = (1+ (random length-of-structures-list))
                and target                     = length-of-acronym then (- target i)
                while (< length-of-structures-list target)
                append (%get-POS-template i) into final-list
                collect (random-word :prepositions) into final-list
                finally (return (append final-list
                                        (%get-POS-template target)))))))
  
  (defun letterp (thing)
    (or (char<= #\a thing #\z) (char<= #\A thing #\Z)))
  