   #
   # This generalized mutation will insert or remove a single item.
   _generalized: (mutation) ->
-    mutation.levels.push new Level(false)
-    @io.load @, mutation, @rootAddress, @_rootLoaded
-
+    mutation.levels.unshift new Level
+    mutation.levels[0].lock @, mutation, @rootAddress, @_rootLoaded
+
+  # Perform the root decision with only a read lock obtained.
   _rootLoaded: (mutation, root) ->
-    mutation.parentLevel = new Level(false)
-    mutation.parentLevel.tier = root
-    mutation.levels.push mutation.parentLevel
-    mutation.parentLevel.lock @, mutation, mutation.parentLevel.tier, @_initialTest
-  
-  # Perform the root decision with only a read lock obtained. If it decides to
-  # mutate the root, we will
-  _initialTest: (mutation) ->
-    mutation.childLevel = new Level(false)
-    mutation.levels.push mutation.childLevel
-    if mutation.decisions.initial.call @, mutation
-      mutation.parentLevel.operations.clear()
-      mutation.parentLevel.upgrade mutation.childLevel, @_initialTestAgain
-    else
-      @_tierDecision mutation
-
-  _initialTestAgain: (mutation) ->
-    if not mutation.initial.call @, mutation
-      mutation.rewind 0
+    mutation.levels[0].tier = root
+    mutation.decisions.initial.call @, mutation
     @_tierDecision mutation
 
   # Determine if we need to lock a tier. We have different criteria for inner
   # tiers with inner tier children then for penultimate inner tiers with leaf
   # tier children.
-  # 
-  # When we encounter a penultimate tier, we continue on to peform the
-  # operations. Otherwise, we make another decision using the next inner tier
-  # child.
   _tierDecision: (mutation) ->
-    if mutation.parentLevel.tier.penultimate
-      @_testInnerTier mutation, mutation.decisions.penultimate, 1, @_operate
+    if mutation.level[0].tier.penultimate
+      @_testInnerTier mutation, mutation.decisions.penultimate, @_operate
     else
-      @_testInnerTier mutation, mutation.decisions.subsequent, 0, @_tierDescend
+      @_testInnerTier mutation, mutation.decisions.subsequent, @_tierDescend
+
+  # Perform decisions related to the inner tier.
+  _testInnerTier: (mutation, decision, next) ->
+    mutation.decisions.swap.call @, mutation
+    if not decision.call @, mutation
+      for level in mutation.levels
+        level.operations = level.operations.filter (operation) ->
+          operation isnt "swap"
+    next.call @, mutation
 
   _tierDescend: (mutation) ->
     branch = @_find(mutation.parentLevel.tier, mutation.sought)
     @io.load mutation.parent, branch, (child) =>
       mutation.parent = child
       mutation.parentLevel = mutation.childLevel
-      mutation.childLevel = new Level(mutation.parentLevel.exclusive)
+      mutation.childLevel = new Level()
       mutation.levels.push mutation.childLevel
-      mutation.shift @_tierDecision
+      @_tierDecision mutation
 
   # When `_operate` is invoked, all the necessary locks have been obtained and
   # we are able to mutate the tree with impunity.

  # Determine if the leaf that will hold the inserted value is full and ready
  # to split, if it is full and part of linked list of b+tree leaves of
  # duplicate index values, or it it can be inserted without splitting.
  _howToInsertLeaf: (mutation) ->
    # By default, return false.
    split = true

    # Find the branch that navigates to the leaf child.
    branch = @_find mutation.parentLevel.tier, mutation.fields
    leaf = @io.load @, mutation, mutation.parentLevel.tier.get(branch).address, @_inspectLeafForSplitLoaded

  # After load, lock the leaf exclusively.
  _inspectLeafForSplitLoaded: (mutation, leaf) ->

    return false
 
  _shouldSplitInner: (mutation) ->
    console.log "_shouldSplitInner"
    structure = mutation.getStructure()
    branch = parent.find(mutation.getComparable())
    child = structure.getStorage().load(mutation.getStash(), parent.getChildAddress(branch))
