anchor.diff:      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_master}),
  +            comm:send_local(self(), {shutdown, negotiate_interval_initiator}),
               DestReconPid =/= undefined andalso
                   comm:send(DestReconPid, {shutdown, no_interval_intersection});
           true ->
  
positive.code:     State#rr_recon_state{ struct = {},
                            method = Method,
                            dest_key = DestKey,
                            master = true };
  
  on({continue, Method, Stage, Struct, Master}, 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 };
  
  on({crash, Pid}, State) ->
      comm:send_local(self(), {shutdown, {fail, crash_of_recon_node, Pid}}),
  
negative.code:                                                 ownerRemotePid = OwnerPid,
                                                  dest_recon_pid = DestReconPid,
                                                  dest_rr_pid = DestRRPid,                                       
                                                  initiator = Initiator, 
                                                  stats = Stats }) ->
      ?TRACE("BEGIN SYNC", []),
      Round = rr_recon_stats:get(round, Stats),
      case Method of
          merkle_tree -> 
              case Initiator of
                  true -> comm:send(DestReconPid, 
                                    {check_node, comm:this(), 
                                     merkle_tree:get_interval(SyncStruct), 
  