anchor.diff:  ;;; Insertion
   
   (defun add-seqs (trie seqs)
  -    (mapcar #'(lambda (seq) (add-seq trie seq))
  -        seqs))
  +    (mapcar #'(lambda (seq) (add-seq trie seq)) seqs))
   
   (defun add-seq (trie seq &optional (count 1))
       "Add a branch to the trie count times. If branch already exists, increase it’s width.
       A count below one is changed to one. Modifies trie in-place."
  -    (when (< count 0) (error (format nil "Negative count ~A." count)))
  +    (when (< count 0)
  +        (error (format nil "Negative count ~A." count)))
       (incf (trie-width trie) count)
       (when (zerop (length seq))
           (add-key trie t count)
           (return-from add-seq trie))
       (let ((symbol (add-key trie (elt seq 0) 0)))
  -        ; (add-key trie (elt seq 0) count)
           (add-seq symbol (subseq seq 1) count)))
   
   (defun add-key (trie key &optional (count 1))
       "Add a node to trie. If node exists, increases it’s width."
  -    (when (< count 0) (error (format nil "Negative count ~A." count)))
  +    (when (< count 0)
  +        (error (format nil "Negative count ~A." count)))
       (let ((node (find-key trie key)))
           (if node
               (incf (trie-width node) count)
  
positive.code:     (when (zerop (length seq))
          (return-from find-seq trie))
      (let ((symbol (find-key trie (elt seq 0))))
          (if (null symbol)
              (return-from find-seq nil)
              (find-seq symbol (subseq seq 1)))))
  
  (defun find-key (trie key)
  
negative.code:     (loop as branch in (trie-branches trie) do
          (print-words branch
              (concatenate 'string prefix (format nil "~A" (trie-key trie)))))
      (when (equal "" (trie-key trie))
          (trie-width trie)))
  
  ; (defmethod print-object ((object trie) stream)
  ;     (when *print-pretty* (format stream "~&~v@T" 2))
  