anchor.diff:                                 segment_acc=[{K,V}],
                                  prefetch=true},
               iterate(iterator_move(Itr, prefetch), IS2);
  -        {Id, _, [_NextSeg | _Remaining], true} ->
  +        {Id, _, [NextSeg | Remaining], true} ->
               %% Pointing at uninteresting segment, but need to halt the
               %% prefetch to ensure the interator can be reused
  -            IS2 = IS#itr_state{segment_acc=[],
  +
  +            %% Do not update segment/final_acc
  +            IS2 = IS#itr_state{current_segment=NextSeg,
  +                               segment_acc=[],
  +                               remaining_segments=Remaining,
                                  final_acc=[{Segment, F(Acc)} | FinalAcc],
  -                               prefetch=false},
  -            iterate(iterator_move(Itr, prefetch_stop), IS2);
  +                               prefetch=true}, % will be after second move
  +            _ = iterator_move(Itr, prefetch_stop), % ignore the pre-fetch,
  +            Seek = encode(Id, NextSeg, <<>>),      % and risk wasting a reseek
  +            iterate(iterator_move(Itr, Seek), IS2);% to get to the next segment
           {Id, _, [NextSeg | Remaining], false} ->
               %% Pointing at uninteresting segment, seek to next interesting one
               Seek = encode(Id, NextSeg, <<>>),
  
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
  