anchor.diff:  get(Key, {_, _, 0, _, _, nil}) ->
       erlang:error({key_not_found, Key});
   get(Key, {_, _, _, SortFunction, State, Tree}) ->
  -    case lookup_1(Key, Tree, SortFunction, State)
  -    of
  +    case lookup_1(Key, Tree, SortFunction, State) of
           {value, Value} ->
               Value;
           _ ->
  
positive.code: % Non-Leaf node.
  lookup_1(Key, {KeyNo, _, KeyValues, Subtrees}, SortFunction, nil) ->
      {Value, Pos} = binary_search(Key, KeyValues, KeyNo, 1, KeyNo, SortFunction),
      case Value == none of
          true ->
              lookup_1(Key, lists:nth(Pos, Subtrees), SortFunction, nil);
          _ ->
              {value, Value}
      end;
  lookup_1(Key, {KeyNo, _, KeyValues, SubtreesKey}, SortFunction, {StateTarget, _, _, LookupFunction} = State) ->
      {Value, Pos} = binary_search(Key, KeyValues, KeyNo, 1, KeyNo, SortFunction),
      case Value == none of
          true ->
              lookup_1(Key, lists:nth(Pos, LookupFunction(StateTarget, lookup, SubtreesKey)), SortFunction, State);
          _ ->
              {value, Value}
  
negative.code:     SubtreesXCLeft = LookupFunction(StateTarget, lookup, SubtreesKeyXCLeft),
      {KeyNoXC, SubtreeNoXC, KeyValuesXC, SubtreesKeyXC} = TreeXC = lists:nth(KeyPos, Subtrees),
      SubtreesXC = LookupFunction(StateTarget, lookup, SubtreesKeyXC),
      {KeyNoXCRight, SubtreeNoXCRight, KeyValuesXCRight, SubtreesKeyXCRight} = case KeyPos of
                                                                                   SubtreeNo ->
                                                                                       {0, 0, [], []};
                                                                                   _ ->
                                                                                       lists:nth(KeyPos + 1, Subtrees)
  