anchor.diff:      end.
   
   compute_forwarding(Mods, Ring) ->
  -    {AllIndices, _} = lists:unzip(riak_core_ring:all_owners(Ring)),
  +    AllIndices = [Index || {Index, _} <- riak_core_ring:all_owners(Ring)],
       Forwarding = [check_forward(Ring, Mod, Index) || Index <- AllIndices,
                                                        Mod <- Mods],
  -    orddict:from_list(Forwarding).
  +    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 = lists:sort([{{Mod, Idx}, Pid} || {Mod, Idx, Pid} <- AllVNodes]),
  -    Diff = NewForwarding -- Forwarding,
  -    [change_forward(VNodes, Mod, Idx, ForwardTo)
  -     || {{Mod, Idx}, ForwardTo} <- Diff],
  +    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 = orddict:store({Mod, Idx}, ForwardTo, Forwarding),
  +    NewForwarding = dict:store({Mod, Idx}, ForwardTo, Forwarding),
       State#state{forwarding=NewForwarding}.
   
   change_forward(VNodes, Mod, Idx, ForwardTo) ->
  -    case orddict:find({Mod, Idx}, VNodes) of
  +    case dict:find({Mod, Idx}, VNodes) of
           error ->
               ok;
           {ok, Pid} ->
  
positive.code: -type repairs() :: [repair()].
  
  -record(state, {idxtab,
                  forwarding :: [{{module(), integer()}, term()}],
                  handoff :: [{{module(), integer()}, term()}],
                  known_modules :: [term()],
                  never_started :: [{integer(), term()}],
                  vnode_start_tokens :: integer(),
  
negative.code:     maybe_trigger_handoff(Mod, Idx, Pid, State).
  
  maybe_trigger_handoff(Mod, Idx, Pid, _State=#state{handoff=HO}) ->
      case dict:find({Mod, Idx}, HO) of
          {ok, TargetNode} ->
              riak_core_vnode:trigger_handoff(Pid, TargetNode),
              ok;
  