anchor.diff:  (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
  -  (if (find #\Space acronym)
  -      (loop for i = 0 then (1+ j)
  -            as j = (position #\Space acronym :start i)
  -            append (get-POS-template (subseq acronym i j))
  -            when j collect '("and")
  -            while j)
  -      (flet ((%get-POS-template (length)
  -               (alexandria: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)
  +  (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))))))))
  +              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)))
  
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 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."
    (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)
  