anchor.diff:      State#rr_recon_state{ struct = {},
                             method = Method,
                             dest_key = DestKey,
  -                          master = true };
  -
  -on({continue, Method, Stage, Struct, Master}, State) ->
  +                          initiator = true };
  +
  +on({continue, Method, Stage, Struct, Initiator}, State) ->
       comm:send_local(State#rr_recon_state.dhtNodePid, {get_state, comm:this(), my_range}),
       State#rr_recon_state{ stage = Stage, 
                             struct = Struct,
                             method = Method,
  -                          master = Master orelse Stage =:= res_shared_interval };
  +                          initiator = Initiator orelse Stage =:= res_shared_interval };
   
   on({crash, Pid}, State) ->
       comm:send_local(self(), {shutdown, {fail, crash_of_recon_node, Pid}}),
  
positive.code: -spec on(message(), state()) -> state().
  on({get_state_response, MyI}, State = 
         #rr_recon_state{ stage = req_shared_interval,
                          master = true,
                          stats = Stats,
                          method = Method,
                          dest_key = DestKey,
  
negative.code:     MyIntersec = find_intersection(MyI, DestI),
      case intervals:is_subset(MyIntersec, MyI) and not intervals:is_empty(MyIntersec) of
          false ->
              comm:send_local(self(), {shutdown, negotiate_interval_initiator}),
              DestReconPid =/= undefined andalso
                  comm:send(DestReconPid, {shutdown, no_interval_intersection});
          true ->
  