=== ITERATION 0 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{a}' at indices 0,0
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'a' not found
Adding new edge to node #0
 => node #0 --> a(0,#)

(0)──a

=== ITERATION 1 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{b}' at indices 1,1
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'b' not found
Adding new edge to node #0
 => node #0 --> b(1,#)

(0)┬─ab
   └─b

=== ITERATION 2 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{c}' at indices 2,2
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'c' not found
Adding new edge to node #0
 => node #0 --> c(2,#)

(0)┬─abc
   ├─bc
   └─c

=== ITERATION 3 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{d}' at indices 3,3
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'd' not found
Adding new edge to node #0
 => node #0 --> d(3,#)

(0)┬─abcd
   ├─bcd
   ├─cd
   └─d

=== ITERATION 4 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{e}' at indices 4,4
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'e' not found
Adding new edge to node #0
 => node #0 --> e(4,#)

(0)┬─abcde
   ├─bcde
   ├─cde
   ├─de
   └─e

=== ITERATION 5 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{f}' at indices 5,5
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'f' not found
Adding new edge to node #0
 => node #0 --> f(5,#)

(0)┬─abcdef
   ├─bcdef
   ├─cdef
   ├─def
   ├─ef
   └─f

=== ITERATION 6 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{a}' at indices 6,6
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'a' found. Values adjusted to:
 => ActiveEdge is now: abcdefa(0,#)
 => DistanceIntoActiveEdge is now: 1
 => UnresolvedSuffixes is now: 0

(0)┬─abcdefa
   ├─bcdefa
   ├─cdefa
   ├─defa
   ├─efa
   └─fa

=== ITERATION 7 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'a{b}' at indices 6,7
 => ActiveNode:             node #0
 => ActiveEdge:             abcdefab(0,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     1
The next character on the current edge is 'b' (suffix added implicitly)
 => DistanceIntoActiveEdge is now: 2

(0)┬─abcdefab
   ├─bcdefab
   ├─cdefab
   ├─defab
   ├─efab
   └─fab

=== ITERATION 8 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'ab{x}' at indices 6,8
 => ActiveNode:             node #0
 => ActiveEdge:             abcdefabx(0,#)
 => DistanceIntoActiveEdge: 2
 => UnresolvedSuffixes:     2
Splitting edge abcdefabx(0,#) at index 2 ('c')
 => Hierarchy is now: node #0 --> ab(0,1) --> node #1 --> cdefabx(2,#)
 => ActiveEdge is now: ab(0,1)
Adding new edge to node #1
 => node #1 --> x(8,#)

(0)┬─ab───────(1)┬─cdefabx
   │             └─x
   ├─bcdefabx
   ├─cdefabx
   ├─defabx
   ├─efabx
   └─fabx

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'b{x}' at indices 7,8
 => ActiveNode:             node #0
 => ActiveEdge:             bcdefabx(1,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     1
Splitting edge bcdefabx(1,#) at index 2 ('c')
 => Hierarchy is now: node #0 --> b(1,1) --> node #2 --> cdefabx(2,#)
 => ActiveEdge is now: b(1,1)
 => Connected node #1 to node #2
Adding new edge to node #2
 => node #2 --> x(8,#)

(0)┬─ab──────(1)┬─cdefabx
   │            └─x
   ├─b───────(2)┬─cdefabx
   │            └─x
   ├─cdefabx
   ├─defabx
   ├─efabx
   └─fabx

The next suffix of 'abcdefabxybcdmnabcdex' to add is '{x}' at indices 8,8
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'x' not found
Adding new edge to node #0
 => node #0 --> x(8,#)

(0)┬─ab──────(1)┬─cdefabx
   │            └─x
   ├─b───────(2)┬─cdefabx
   │            └─x
   ├─cdefabx
   ├─defabx
   ├─efabx
   ├─fabx
   └─x

=== ITERATION 9 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{y}' at indices 9,9
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'y' not found
Adding new edge to node #0
 => node #0 --> y(9,#)

(0)┬─ab───────(1)┬─cdefabxy
   │             └─xy
   ├─b────────(2)┬─cdefabxy
   │             └─xy
   ├─cdefabxy
   ├─defabxy
   ├─efabxy
   ├─fabxy
   ├─xy
   └─y

=== ITERATION 10 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{b}' at indices 10,10
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'b' found. Values adjusted to:
Active point is now at or beyond edge boundary and will be moved until it falls inside an edge boundary
 => ActiveEdge is now: 
 => DistanceIntoActiveEdge is now: 0
 => UnresolvedSuffixes is now: 0

(0)┬─ab────────(1)┬─cdefabxyb
   │              └─xyb
   ├─b─────────(2)┬─cdefabxyb
   │              └─xyb
   ├─cdefabxyb
   ├─defabxyb
   ├─efabxyb
   ├─fabxyb
   ├─xyb
   └─yb

=== ITERATION 11 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'b{c}' at indices 10,11
 => ActiveNode:             node #2
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     1
Existing edge for node #2 starting with 'c' found. Values adjusted to:
 => ActiveEdge is now: cdefabxybc(2,#)
 => DistanceIntoActiveEdge is now: 1
 => UnresolvedSuffixes is now: 1

(0)┬─ab─────────(1)┬─cdefabxybc
   │               └─xybc
   ├─b──────────(2)┬─cdefabxybc
   │               └─xybc
   ├─cdefabxybc
   ├─defabxybc
   ├─efabxybc
   ├─fabxybc
   ├─xybc
   └─ybc

=== ITERATION 12 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'bc{d}' at indices 10,12
 => ActiveNode:             node #2
 => ActiveEdge:             cdefabxybcd(2,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     2
The next character on the current edge is 'd' (suffix added implicitly)
 => DistanceIntoActiveEdge is now: 2

(0)┬─ab──────────(1)┬─cdefabxybcd
   │                └─xybcd
   ├─b───────────(2)┬─cdefabxybcd
   │                └─xybcd
   ├─cdefabxybcd
   ├─defabxybcd
   ├─efabxybcd
   ├─fabxybcd
   ├─xybcd
   └─ybcd

=== ITERATION 13 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'bcd{m}' at indices 10,13
 => ActiveNode:             node #2
 => ActiveEdge:             cdefabxybcdm(2,#)
 => DistanceIntoActiveEdge: 2
 => UnresolvedSuffixes:     3
Splitting edge cdefabxybcdm(2,#) at index 4 ('e')
 => Hierarchy is now: node #2 --> cd(2,3) --> node #3 --> efabxybcdm(4,#)
 => ActiveEdge is now: cd(2,3)
Adding new edge to node #3
 => node #3 --> m(13,#)
The linked node for active node node #2 is [null]

(0)┬─ab───────────(1)┬─cdefabxybcdm
   │                 └─xybcdm
   ├─b────────────(2)┬─cd─────(3)┬─efabxybcdm
   │                 │           └─m
   │                 └─xybcdm
   ├─cdefabxybcdm
   ├─defabxybcdm
   ├─efabxybcdm
   ├─fabxybcdm
   ├─xybcdm
   └─ybcdm

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'cd{m}' at indices 11,13
 => ActiveNode:             node #0
 => ActiveEdge:             cdefabxybcdm(2,#)
 => DistanceIntoActiveEdge: 2
 => UnresolvedSuffixes:     2
Splitting edge cdefabxybcdm(2,#) at index 4 ('e')
 => Hierarchy is now: node #0 --> cd(2,3) --> node #4 --> efabxybcdm(4,#)
 => ActiveEdge is now: cd(2,3)
 => Connected node #3 to node #4
Adding new edge to node #4
 => node #4 --> m(13,#)

(0)┬─ab──────────(1)┬─cdefabxybcdm
   │                └─xybcdm
   ├─b───────────(2)┬─cd─────(3)┬─efabxybcdm
   │                │           └─m
   │                └─xybcdm
   ├─cd──────────(4)┬─efabxybcdm
   │                └─m
   ├─defabxybcdm
   ├─efabxybcdm
   ├─fabxybcdm
   ├─xybcdm
   └─ybcdm

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'd{m}' at indices 12,13
 => ActiveNode:             node #0
 => ActiveEdge:             defabxybcdm(3,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     1
Splitting edge defabxybcdm(3,#) at index 4 ('e')
 => Hierarchy is now: node #0 --> d(3,3) --> node #5 --> efabxybcdm(4,#)
 => ActiveEdge is now: d(3,3)
 => Connected node #4 to node #5
Adding new edge to node #5
 => node #5 --> m(13,#)

(0)┬─ab─────────(1)┬─cdefabxybcdm
   │               └─xybcdm
   ├─b──────────(2)┬─cd─────(3)┬─efabxybcdm
   │               │           └─m
   │               └─xybcdm
   ├─cd─────────(4)┬─efabxybcdm
   │               └─m
   ├─d──────────(5)┬─efabxybcdm
   │               └─m
   ├─efabxybcdm
   ├─fabxybcdm
   ├─xybcdm
   └─ybcdm

The next suffix of 'abcdefabxybcdmnabcdex' to add is '{m}' at indices 13,13
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'm' not found
Adding new edge to node #0
 => node #0 --> m(13,#)

(0)┬─ab─────────(1)┬─cdefabxybcdm
   │               └─xybcdm
   ├─b──────────(2)┬─cd─────(3)┬─efabxybcdm
   │               │           └─m
   │               └─xybcdm
   ├─cd─────────(4)┬─efabxybcdm
   │               └─m
   ├─d──────────(5)┬─efabxybcdm
   │               └─m
   ├─efabxybcdm
   ├─fabxybcdm
   ├─m
   ├─xybcdm
   └─ybcdm

=== ITERATION 14 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{n}' at indices 14,14
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'n' not found
Adding new edge to node #0
 => node #0 --> n(14,#)

(0)┬─ab──────────(1)┬─cdefabxybcdmn
   │                └─xybcdmn
   ├─b───────────(2)┬─cd──────(3)┬─efabxybcdmn
   │                │            └─mn
   │                └─xybcdmn
   ├─cd──────────(4)┬─efabxybcdmn
   │                └─mn
   ├─d───────────(5)┬─efabxybcdmn
   │                └─mn
   ├─efabxybcdmn
   ├─fabxybcdmn
   ├─mn
   ├─n
   ├─xybcdmn
   └─ybcdmn

=== ITERATION 15 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is '{a}' at indices 15,15
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'a' found. Values adjusted to:
 => ActiveEdge is now: ab(0,1)
 => DistanceIntoActiveEdge is now: 1
 => UnresolvedSuffixes is now: 0

(0)┬─ab───────────(1)┬─cdefabxybcdmna
   │                 └─xybcdmna
   ├─b────────────(2)┬─cd───────(3)┬─efabxybcdmna
   │                 │             └─mna
   │                 └─xybcdmna
   ├─cd───────────(4)┬─efabxybcdmna
   │                 └─mna
   ├─d────────────(5)┬─efabxybcdmna
   │                 └─mna
   ├─efabxybcdmna
   ├─fabxybcdmna
   ├─mna
   ├─na
   ├─xybcdmna
   └─ybcdmna

=== ITERATION 16 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'a{b}' at indices 15,16
 => ActiveNode:             node #0
 => ActiveEdge:             ab(0,1)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     1
The next character on the current edge is 'b' (suffix added implicitly)
 => DistanceIntoActiveEdge is now: 2
Active point is now at or beyond edge boundary and will be moved until it falls inside an edge boundary

(0)┬─ab────────────(1)┬─cdefabxybcdmnab
   │                  └─xybcdmnab
   ├─b─────────────(2)┬─cd────────(3)┬─efabxybcdmnab
   │                  │              └─mnab
   │                  └─xybcdmnab
   ├─cd────────────(4)┬─efabxybcdmnab
   │                  └─mnab
   ├─d─────────────(5)┬─efabxybcdmnab
   │                  └─mnab
   ├─efabxybcdmnab
   ├─fabxybcdmnab
   ├─mnab
   ├─nab
   ├─xybcdmnab
   └─ybcdmnab

=== ITERATION 17 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'ab{c}' at indices 15,17
 => ActiveNode:             node #1
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     2
Existing edge for node #1 starting with 'c' found. Values adjusted to:
 => ActiveEdge is now: cdefabxybcdmnabc(2,#)
 => DistanceIntoActiveEdge is now: 1
 => UnresolvedSuffixes is now: 2

(0)┬─ab─────────────(1)┬─cdefabxybcdmnabc
   │                   └─xybcdmnabc
   ├─b──────────────(2)┬─cd─────────(3)┬─efabxybcdmnabc
   │                   │               └─mnabc
   │                   └─xybcdmnabc
   ├─cd─────────────(4)┬─efabxybcdmnabc
   │                   └─mnabc
   ├─d──────────────(5)┬─efabxybcdmnabc
   │                   └─mnabc
   ├─efabxybcdmnabc
   ├─fabxybcdmnabc
   ├─mnabc
   ├─nabc
   ├─xybcdmnabc
   └─ybcdmnabc

=== ITERATION 18 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'abc{d}' at indices 15,18
 => ActiveNode:             node #1
 => ActiveEdge:             cdefabxybcdmnabcd(2,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     3
The next character on the current edge is 'd' (suffix added implicitly)
 => DistanceIntoActiveEdge is now: 2

(0)┬─ab──────────────(1)┬─cdefabxybcdmnabcd
   │                    └─xybcdmnabcd
   ├─b───────────────(2)┬─cd──────────(3)┬─efabxybcdmnabcd
   │                    │                └─mnabcd
   │                    └─xybcdmnabcd
   ├─cd──────────────(4)┬─efabxybcdmnabcd
   │                    └─mnabcd
   ├─d───────────────(5)┬─efabxybcdmnabcd
   │                    └─mnabcd
   ├─efabxybcdmnabcd
   ├─fabxybcdmnabcd
   ├─mnabcd
   ├─nabcd
   ├─xybcdmnabcd
   └─ybcdmnabcd

=== ITERATION 19 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'abcd{e}' at indices 15,19
 => ActiveNode:             node #1
 => ActiveEdge:             cdefabxybcdmnabcde(2,#)
 => DistanceIntoActiveEdge: 2
 => UnresolvedSuffixes:     4
The next character on the current edge is 'e' (suffix added implicitly)
 => DistanceIntoActiveEdge is now: 3

(0)┬─ab───────────────(1)┬─cdefabxybcdmnabcde
   │                     └─xybcdmnabcde
   ├─b────────────────(2)┬─cd───────────(3)┬─efabxybcdmnabcde
   │                     │                 └─mnabcde
   │                     └─xybcdmnabcde
   ├─cd───────────────(4)┬─efabxybcdmnabcde
   │                     └─mnabcde
   ├─d────────────────(5)┬─efabxybcdmnabcde
   │                     └─mnabcde
   ├─efabxybcdmnabcde
   ├─fabxybcdmnabcde
   ├─mnabcde
   ├─nabcde
   ├─xybcdmnabcde
   └─ybcdmnabcde

=== ITERATION 20 ===
The next suffix of 'abcdefabxybcdmnabcdex' to add is 'abcde{x}' at indices 15,20
 => ActiveNode:             node #1
 => ActiveEdge:             cdefabxybcdmnabcdex(2,#)
 => DistanceIntoActiveEdge: 3
 => UnresolvedSuffixes:     5
Splitting edge cdefabxybcdmnabcdex(2,#) at index 5 ('f')
 => Hierarchy is now: node #1 --> cde(2,4) --> node #6 --> fabxybcdmnabcdex(5,#)
 => ActiveEdge is now: cde(2,4)
Adding new edge to node #6
 => node #6 --> x(20,#)
The linked node for active node node #1 is node #2
 => ActiveNode is now: node #2
Active point is now at or beyond edge boundary and will be moved until it falls inside an edge boundary

(0)┬─ab────────────────(1)┬─cde───────────(6)┬─fabxybcdmnabcdex
   │                      │                  └─x
   │                      └─xybcdmnabcdex
   ├─b─────────────────(2)┬─cd────────────(3)┬─efabxybcdmnabcdex
   │                      │                  └─mnabcdex
   │                      └─xybcdmnabcdex
   ├─cd────────────────(4)┬─efabxybcdmnabcdex
   │                      └─mnabcdex
   ├─d─────────────────(5)┬─efabxybcdmnabcdex
   │                      └─mnabcdex
   ├─efabxybcdmnabcdex
   ├─fabxybcdmnabcdex
   ├─mnabcdex
   ├─nabcdex
   ├─xybcdmnabcdex
   └─ybcdmnabcdex

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'bcde{x}' at indices 16,20
 => ActiveNode:             node #3
 => ActiveEdge:             efabxybcdmnabcdex(4,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     4
Splitting edge efabxybcdmnabcdex(4,#) at index 5 ('f')
 => Hierarchy is now: node #3 --> e(4,4) --> node #7 --> fabxybcdmnabcdex(5,#)
 => ActiveEdge is now: e(4,4)
 => Connected node #6 to node #7
Adding new edge to node #7
 => node #7 --> x(20,#)
The linked node for active node node #3 is node #4
 => ActiveNode is now: node #4

(0)┬─ab────────────────(1)┬─cde───────────(6)┬─fabxybcdmnabcdex
   │                      │                  └─x
   │                      └─xybcdmnabcdex
   ├─b─────────────────(2)┬─cd────────────(3)┬─e────────(7)┬─fabxybcdmnabcdex
   │                      │                  │             └─x
   │                      │                  └─mnabcdex
   │                      └─xybcdmnabcdex
   ├─cd────────────────(4)┬─efabxybcdmnabcdex
   │                      └─mnabcdex
   ├─d─────────────────(5)┬─efabxybcdmnabcdex
   │                      └─mnabcdex
   ├─efabxybcdmnabcdex
   ├─fabxybcdmnabcdex
   ├─mnabcdex
   ├─nabcdex
   ├─xybcdmnabcdex
   └─ybcdmnabcdex

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'cde{x}' at indices 17,20
 => ActiveNode:             node #4
 => ActiveEdge:             efabxybcdmnabcdex(4,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     3
Splitting edge efabxybcdmnabcdex(4,#) at index 5 ('f')
 => Hierarchy is now: node #4 --> e(4,4) --> node #8 --> fabxybcdmnabcdex(5,#)
 => ActiveEdge is now: e(4,4)
 => Connected node #7 to node #8
Adding new edge to node #8
 => node #8 --> x(20,#)
The linked node for active node node #4 is node #5
 => ActiveNode is now: node #5

(0)┬─ab────────────────(1)┬─cde───────────(6)┬─fabxybcdmnabcdex
   │                      │                  └─x
   │                      └─xybcdmnabcdex
   ├─b─────────────────(2)┬─cd────────────(3)┬─e────────(7)┬─fabxybcdmnabcdex
   │                      │                  │             └─x
   │                      │                  └─mnabcdex
   │                      └─xybcdmnabcdex
   ├─cd────────────────(4)┬─e────────(8)┬─fabxybcdmnabcdex
   │                      │             └─x
   │                      └─mnabcdex
   ├─d─────────────────(5)┬─efabxybcdmnabcdex
   │                      └─mnabcdex
   ├─efabxybcdmnabcdex
   ├─fabxybcdmnabcdex
   ├─mnabcdex
   ├─nabcdex
   ├─xybcdmnabcdex
   └─ybcdmnabcdex

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'de{x}' at indices 18,20
 => ActiveNode:             node #5
 => ActiveEdge:             efabxybcdmnabcdex(4,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     2
Splitting edge efabxybcdmnabcdex(4,#) at index 5 ('f')
 => Hierarchy is now: node #5 --> e(4,4) --> node #9 --> fabxybcdmnabcdex(5,#)
 => ActiveEdge is now: e(4,4)
 => Connected node #8 to node #9
Adding new edge to node #9
 => node #9 --> x(20,#)
The linked node for active node node #5 is [null]

(00)┬─ab────────────────(01)┬─cde───────────(06)┬─fabxybcdmnabcdex
    │                       │                   └─x
    │                       └─xybcdmnabcdex
    ├─b─────────────────(02)┬─cd────────────(03)┬─e────────(07)┬─fabxybcdmnabcdex
    │                       │                   │              └─x
    │                       │                   └─mnabcdex
    │                       └─xybcdmnabcdex
    ├─cd────────────────(04)┬─e────────(08)┬─fabxybcdmnabcdex
    │                       │              └─x
    │                       └─mnabcdex
    ├─d─────────────────(05)┬─e────────(09)┬─fabxybcdmnabcdex
    │                       │              └─x
    │                       └─mnabcdex
    ├─efabxybcdmnabcdex
    ├─fabxybcdmnabcdex
    ├─mnabcdex
    ├─nabcdex
    ├─xybcdmnabcdex
    └─ybcdmnabcdex

The next suffix of 'abcdefabxybcdmnabcdex' to add is 'e{x}' at indices 19,20
 => ActiveNode:             node #0
 => ActiveEdge:             efabxybcdmnabcdex(4,#)
 => DistanceIntoActiveEdge: 1
 => UnresolvedSuffixes:     1
Splitting edge efabxybcdmnabcdex(4,#) at index 5 ('f')
 => Hierarchy is now: node #0 --> e(4,4) --> node #10 --> fabxybcdmnabcdex(5,#)
 => ActiveEdge is now: e(4,4)
 => Connected node #9 to node #10
Adding new edge to node #10
 => node #10 --> x(20,#)

(00)┬─ab───────────────(01)┬─cde───────────(06)┬─fabxybcdmnabcdex
    │                      │                   └─x
    │                      └─xybcdmnabcdex
    ├─b────────────────(02)┬─cd────────────(03)┬─e────────(07)┬─fabxybcdmnabcdex
    │                      │                   │              └─x
    │                      │                   └─mnabcdex
    │                      └─xybcdmnabcdex
    ├─cd───────────────(04)┬─e────────(08)┬─fabxybcdmnabcdex
    │                      │              └─x
    │                      └─mnabcdex
    ├─d────────────────(05)┬─e────────(09)┬─fabxybcdmnabcdex
    │                      │              └─x
    │                      └─mnabcdex
    ├─e────────────────(10)┬─fabxybcdmnabcdex
    │                      └─x
    ├─fabxybcdmnabcdex
    ├─mnabcdex
    ├─nabcdex
    ├─xybcdmnabcdex
    └─ybcdmnabcdex

The next suffix of 'abcdefabxybcdmnabcdex' to add is '{x}' at indices 20,20
 => ActiveNode:             node #0
 => ActiveEdge:             none
 => DistanceIntoActiveEdge: 0
 => UnresolvedSuffixes:     0
Existing edge for node #0 starting with 'x' found. Values adjusted to:
 => ActiveEdge is now: xybcdmnabcdex(8,#)
 => DistanceIntoActiveEdge is now: 1
 => UnresolvedSuffixes is now: 0

(00)┬─ab───────────────(01)┬─cde───────────(06)┬─fabxybcdmnabcdex
    │                      │                   └─x
    │                      └─xybcdmnabcdex
    ├─b────────────────(02)┬─cd────────────(03)┬─e────────(07)┬─fabxybcdmnabcdex
    │                      │                   │              └─x
    │                      │                   └─mnabcdex
    │                      └─xybcdmnabcdex
    ├─cd───────────────(04)┬─e────────(08)┬─fabxybcdmnabcdex
    │                      │              └─x
    │                      └─mnabcdex
    ├─d────────────────(05)┬─e────────(09)┬─fabxybcdmnabcdex
    │                      │              └─x
    │                      └─mnabcdex
    ├─e────────────────(10)┬─fabxybcdmnabcdex
    │                      └─x
    ├─fabxybcdmnabcdex
    ├─mnabcdex
    ├─nabcdex
    ├─xybcdmnabcdex
    └─ybcdmnabcdex