 ;; to the pool to redistribute. Use the link after if the run includes the
 ;; first child.
 ;;
-;; Two underflowing partitions need to be merged, but still form an
-;; underflowing partition:
-;;
-;;              ..O..
-;;             /     \
-;;            /       \
-;;           O        .O.
-;;           |       / | \
-;;           *      O  O  O
-;;           |     /|\/|\/ \
-;;     >  [->U<-]  ####### #
-;;
-;;              ..O..
-;;             /     \
-;;            /       \
-;;           O        .O.
-;;           |       / | \
-;;     >    [U]     O  O  O
-;;                 /|\/|\/ \
-;;                 ####### #
-;;
-;;              ..O..
-;;             /     \
-;;            /       \
-;;     >    [U]       .O.
-;;                   / | \
-;;                  O  O  O
-;;                 /|\/|\/ \
-;;                 ####### #
-;;
-;;     >       [O](U)
-;;              |
-;;            ..O..
-;;           /  |  \
-;;          O   O   O
-;;         /|\ /|\ / \
-;;         ### ### # #
-;;
-;;              O
-;;              |
-;;     >      .[O]. (U)
-;;           /  |  \
-;;          O   O   O
-;;         /|\ /|\ / \
-;;         ### ### # #
-;;
-;;              O
-;;              |
-;;            ..O..
-;;           /  |  \
-;;     >   [O]  O   O
-;;        // \\/|\ / \
-;;        U# U@### # #
-;;
-;; Again, redistribute the records in the underflowing partitions.
-;;
-;;              O
-;;              |
-;;            ..O..
-;;           /  |  \
-;;          O   O   O
-;;         /|\ /|\ / \
-;;     >  [@@@]### # #
-;;
-;;              O
-;;              |
-;;            ..O..
-;;           /  |  \
-;;     >   [*]  O   O
-;;         /|\ /|\ / \
-;;         @@@ ### # #
-;;
-;;              O
-;;              |
-;;     >      .[*].
-;;           /  |  \
-;;          *   O   O
-;;         /|\ /|\ / \
-;;         @@@ ### # #
-;;
-;; Fast forward, deleting a subtree...
-;;
-;;              O
-;;              |
-;;            ..*..
-;;           /  |  \
-;;     >    *  [x]  O
-;;         /|\ /|\ / \
-;;     >   @@@[xxx]# #
-;;
-;; Insert nodes into right subtree, resulting in splitting multiple partitions.
-;;
-;;              O
-;;              |
-;;            ..*..
-;;           /     \
-;;          *       *
-;;         /|\    //|\\
-;;     >  @ @ @  [#@@@@]
-;;
-;; Back to distribution phase, fix overflow by splitting the node:
-;;              O
-;;              |
-;;            ..*..
-;;           /  |  \
-;;     >    *  [*   *]
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
-;;
-;;              *
-;;              |
-;;     >      .[*].
-;;           /  |  \
-;;          *   *   *
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
-;;
-;;     >       [*]
-;;              |
-;;            ..*..
-;;           /  |  \
-;;          *   *   *
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
-;;
-;; Now that we're back at the root, we can serialize out the resulting tree.
-;;
-;;              *
-;;              |
-;;     >      .[+].
-;;           /  |  \
-;;          +   +   +
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
+;;               O
+;;               |
+;;           ....*....
+;;          /   / \   \
+;;     >   *   O  [*   *]
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
+;;
+;;               *
+;;               |
+;;     >     ...[*]...
+;;          /   / \   \
+;;         *   O   *   *
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
+;;
+;;     >        [*]
+;;               |
+;;           ....*....
+;;          /   / \   \
+;;         *   O   *   *
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
+
+
+;; ### Serialize
+;;
+;; Now that we're back at the root, we can serialize out the resulting tree of
+;; index nodes. One branch is reused entirely from the original tree, since it
+;; hasn't been changed. All the partition leaves are serialized already at this
+;; point.
+;;
+;;               *
+;;               |
+;;     >     ...[+]...
+;;          /   / \   \
+;;     >  [+]  O  [+] [+]
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
 ;;
 ;; If the upward recursion reaches a branch with a single child, we're on a path
 ;; up to the root, so return the subtree directly, decreasing the height of the
 ;; tree.
 ;;
-;;     >       [*]
-;;              |
-;;            ..+..
-;;           /  |  \
-;;          +   +   +
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
+;;     >        [*]
+;;               |
+;;           ....+....
+;;          /   / \   \
+;;         +   O   +   +
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
 ;;
 ;; Resulting balanced tree:
 ;;
-;;            ..+..
-;;           /  |  \
-;;          +   +   +
-;;         /|\ / \ /|\
-;;         @@@ # @ @@@
+;;           ....+....
+;;          /   / \   \
+;;         +   O   +   +
+;;        /|\ /|\ / \ /|\
+;;        @#@ ### # @ @@@
 
 
 ;; ### References

;;          /|\    /|\/|\/ \
;;     >   U x[U]  ####### #
;;
;; ### Redistribute Children
;;
;; In the **distribution** phase, any candidate children which have over or

;;             |\  /|\/|\/ \
;;             # # ####### #
;;
;;             ...O...
;;            /       \
;;     > (U)[O]       .O.
;;           |       / | \
;;           O      O  O  O
;;          / \    /|\/|\/ \
;;         #   #   ####### #
;;
;; When an orphaned subtree is being passed to the next branch, and the current
;; node's height is one more than the subtree root, insert it as a child of the
;; current node:
;;
;;             ...O...
;;            /       \
;;           O        .O.
;;           |       / | \
;;     > (U)[*]     O  O  O
;;          / \    /|\/|\/ \
;;         #   #   ####### #
;;
;;             ...O...
;;            /       \
;;           O        .O.
;;           |       / | \
;;     >    [*]     O  O  O
;;          /|\    /|\/|\/ \
;;         U # #   ####### #
;;
;; Apply updates to the remaining two partitions, deleting one and creating a
;; second underflowing partition:
;;
;;             ...O...
;;            /       \
;;           O        .O.
;;           |       / | \
