anchor.diff:            pool_config :: tuple() | undefined,
             manager_event_timer :: reference(),
             inactivity_timeout :: non_neg_integer() 
  -               }).
  +         }).
   
   start_link(Mod, Index, Forward) ->
       start_link(Mod, Index, 0, Forward).
  
positive.code:     lager:debug("Forwarding (~p) {~p,~p} -> ~p~n",
                  [Type, State#state.index, node(), ForwardTo]),
      riak_core_vnode_master:command_unreliable(ForwardTo, Request, Sender,
                                                riak_core_vnode_master:reg_name(State#state.mod)),
      continue(State).
  
  %% @doc during ring resizing if we have completed a transfer to the index that will
  %% handle request in future ring we forward to it. Otherwise we delegate
  
negative.code:         {_, undefined, _} -> vnode_command(Sender, Request, State);
          %% implicit forwarding after ownership_transfer/hinted_handoff
          {_, F, _} when not is_list(F) ->
              vnode_forward(implicit, {Index, Forward}, Sender, Request, State),
              continue(State);
          %% during resize we can't forward a request w/o request hash, always handle locally
          {_, _, undefined} -> vnode_command(Sender, Request, State);
          %% possible forwarding during ring resizing
  