anchor.diff:                                     levels=Levels}) ->
       LastLevel = Levels,
       Hashes = orddict:from_list(hashes(State, Segments)),
  +    %% Paranoia to make sure all of the hash entries are updated as expected
  +    lager:debug("segments ~p -> hashes ~p\n", [Segments, Hashes]),
  +    case {Segments, length(Segments), length(Hashes)} of
  +	{?ALL_SEGMENTS, _, _} ->
  +	    NextRebuild = full, % Paranoia to crash if ever here on incremental
  +	    ok;
  +	{_, Len, Len} ->
  +	    ok;
  +	{_, _SegLen, _HashLen} ->
  +	    %% At this point the hashes are no longer sufficient to update
  +	    %% the upper trees.  Alternative is to crash here, but that would
  +	    %% lose updates and is the action taken on repair anyway.
  +	    %% Save the customer some pain by doing that now and log.
  +	    %% Enable lager debug tracing with lager:trace_file(hashtree, "/tmp/ht.trace"
  +	    %% to get the detailed segment information.
  +	    lager:warning("Incremental AAE hash was unable to find all required data, "
  +			  "forcing full rebuild of ~p", [State#state.path]),
  +	    update_perform(State#state{next_rebuild = full})
  +    end,
       Groups = group(Hashes, Width),
       update_levels(LastLevel, Groups, State, NextRebuild).
   
  
positive.code:                           B = Remote(get_bucket, {Level, Bucket}),
                            Delta = riak_ensemble_util:orddict_delta(lists:keysort(1, A),
                                                                     lists:keysort(1, B)),
                            Diffs = Delta,
                            [BK || {BK, _} <- Diffs]
                    end, Buckets).
  
negative.code:                    encode(Id, First, <<>>)
             end,
      IS2 = iterate(iterator_move(Itr, Seek), IS1),
      #itr_state{remaining_segments = LeftOver,
                 current_segment=LastSegment,
                 segment_acc=LastAcc,
                 final_acc=FA} = IS2,
  
      %% iterate completes without processing the last entries in the state.  Compute
      %% the final visited segment, and add calls to the F([]) for all of the segments
      %% that do not exist at the end of the file (due to deleting the last entry in the
      %% segment).
      Result = [{LeftSeg, F([])} || LeftSeg <- lists:reverse(LeftOver),
  				  LeftSeg =/= '*'] ++
  	[{LastSegment, F(LastAcc)} | FA],
      case Result of
          [{'*', _}] ->
              %% Handle wildcard select when all segments are empty
  