anchor.diff:      maybe_trigger_handoff(Mod, Idx, Pid, State),
       {noreply, State};
   handle_vnode_event(handoff_complete, Mod, Idx, Pid, State) ->
  -    NewHO = orddict:erase({Mod, Idx}, State#state.handoff),
  +    NewHO = dict:erase({Mod, Idx}, State#state.handoff),
       gen_fsm:send_all_state_event(Pid, finish_handoff),
       {noreply, State#state{handoff=NewHO}};
   handle_vnode_event(handoff_error, Mod, Idx, Pid, State) ->
  -    NewHO = orddict:erase({Mod, Idx}, State#state.handoff),
  +    NewHO = dict:erase({Mod, Idx}, State#state.handoff),
       gen_fsm:send_all_state_event(Pid, cancel_handoff),
       {noreply, State#state{handoff=NewHO}}.
   
  
positive.code:                          end, Types2, [Pids2, Forwarding2, Handoff2]),
      Status.
  
  update_never_started(Ring, State) ->
      {Indices, _} = lists:unzip(riak_core_ring:all_owners(Ring)),
      lists:foldl(fun({_App, Mod}, StateAcc) ->
                          case lists:member(Mod, StateAcc#state.known_modules) of
                              false ->
                                  update_never_started(Mod, Indices, StateAcc);
                              true ->
                                  StateAcc
                          end
                  end, State, riak_core:vnode_modules()).
  
  update_never_started(Mod, Indices, State) ->
      IdxPids = get_all_index_pid(Mod, []),
  
negative.code:     end.
  
  compute_forwarding(Mods, Ring) ->
      AllIndices = [Index || {Index, _} <- riak_core_ring:all_owners(Ring)],
      Forwarding = [check_forward(Ring, Mod, Index) || Index <- AllIndices,
                                                       Mod <- Mods],
      dict:from_list(Forwarding).
  
  update_forwarding(AllVNodes, Mods, Ring,
                    State=#state{forwarding=Forwarding}) ->
      NewForwarding = compute_forwarding(Mods, Ring),
  
      %% Inform vnodes that have changed forwarding status
      VNodes = dict:from_list([{{Mod, Idx}, Pid} || {Mod, Idx, Pid} <- AllVNodes]),
      Diff = dict:filter(fun(K,V) ->
                                 dict:find(K, Forwarding) /= {ok, V}
                         end, NewForwarding),
      dict:fold(fun({Mod, Idx}, ForwardTo, _) ->
                        change_forward(VNodes, Mod, Idx, ForwardTo),
                        ok
                end, ok, Diff),
  
      State#state{forwarding=NewForwarding}.
  
  update_forwarding({Mod, Idx}, Ring, State=#state{forwarding=Forwarding}) ->
      {_, ForwardTo} = check_forward(Ring, Mod, Idx),
      NewForwarding = dict:store({Mod, Idx}, ForwardTo, Forwarding),
      State#state{forwarding=NewForwarding}.
  
  change_forward(VNodes, Mod, Idx, ForwardTo) ->
      case dict:find({Mod, Idx}, VNodes) of
          error ->
              ok;
          {ok, Pid} ->
  