anchor.diff:  ;; Traversal & printing
   
   ; (defmethod print-object ((object trie) stream)
  -;     (when *pretty-print* (format stream "~&~v@T" 2))
  +;     (when *print-pretty* (format stream "~&~v@T" 2))
   ;     (format stream "(~S ~d" (trie-key trie) (trie-width trie))
   ;     (when (leafp trie)
   ;         (loop as branch in (trie-branches trie) do
   ;             (print branch)))
   ;     (format stream ")"))
   
  -(defun pprint-trie (*standard-output* trie)
  -    ; (format *standard-output* "~&")
  +(defun pprint-trie (*standard-output* trie &key (raw nil))
  +    (setf *print-miser-width* nil)  ; Miser mode disables pprint-indent!
       (pprint-logical-block (*standard-output* trie :prefix "(" :suffix ")")
  -        ; (format *standard-output* "~&")
           ; Print key
           (if (characterp (first trie))
               (write-char (pprint-pop))
               (write (pprint-pop)))
           (write-char #\Space)
  -        
           ; Print width
  +        (pprint-indent :current 0)
           (write (pprint-pop))
  -        (pprint-indent :current 0)
  -        
           ; Branches
           (if (leafp trie)
               ; Has branches
               (progn
  -                ; (write-char #\Space)
  -                (pprint-newline :mandatory)
  -                ; (pprint-indent :current 4)
  -                ; (pprint-tab :line 4 2)
  -                ; (write :+)
  -                ;(pprint-newline :mandatory)
  -                
  -                ; (pprint-tab :line 4 2)
  -                ; (pprint-indent :current 8)
  -                
                   ; Print list of Branches
  -                ; (write-char #\Space)
  -                ; (pprint-newline :miser)
  -                
  +                (write-char #\Space)
  +                (when *debug* (write :+))
                   (loop as branch in (trie-branches trie) do
  -                    (pprint-trie *standard-output* branch)
  -                    (pprint-exit-if-list-exhausted))
  +                    (when *debug* (write :~))
  +                    ; Word endings
  +                    (when (and (not raw) (wordp trie))
  +                        (write-char #\•)
  +                        (return))
  +                    (pprint-newline :mandatory) ; THIS makes the newline after leaf!
  +                    (pprint-indent :current 0)
  +                    (pprint-trie *standard-output* branch :raw raw) ; Next level
  +                    (pprint-exit-if-list-exhausted)                 ; Exit after leaf
  +                    (when *debug* (write :*))
  +                    )
  +                (when *debug* (write :@))
                   )
               ; Is leaf
               (progn
  -                (write :%)
  -                ; (pprint-exit-if-list-exhausted)
  -                ))
  -        
  -        ; Place between closing parens
  -        ; (pprint-exit-if-list-exhausted)
  -        
  -        ; Extra after branches, before closing parens
  -        ; (write :#)
  -        )
  -    (pprint-newline :mandatory)
  -    )
  -    
  -    
  -    (when *pretty-print* (format stream "~&~v@T" 2))
  -    (format stream "(~S ~d" (trie-key trie) (trie-width trie))
  -    (when (leafp trie)
  -        (loop as branch in (trie-branches trie) do
  -            (print branch)))
  -    (format stream ")"))
  +                (when *debug* (write :%))
  +                (pprint-exit-if-list-exhausted)))))
   
   (defun print-trie (trie &optional (depth 0) &key (indent nil))
       "Traverse tries printing out nodes"
  
positive.code: 
  (defun test ()
      (setf r (make-trie))
      (add-seqs r '("blow" "boa" "blush")))
  
  ; Sentence level
  
  
negative.code: ;             (return-from remove-seq nil))
  ;         (remove-seq symbol (subseq seq 1) count)))
  
  (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)))
      (incf (trie-width trie) count)
      (if (zerop (length seq))
          (progn (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)))
  
  ; Node or symbol level
  
  (defun wordp (trie)
      (find-key trie t))
  
  (defun leafp (trie)
      (car (trie-branches trie)))
  