anchor.diff:              end,
               rr_recon_stats:set(
                 [{tree_compareLeft, ?IIF(Initiator, 1, 0)},
  -               {tree_size, merkle_tree:size_detail(SyncStruct)}], Stats);
  +               {tree_size, merkle_tree:size_detail(MySyncStruct)}], Stats);
           bloom when Initiator =:= false ->
               send(DestRRPid, {continue_recon, comm:make_global(OwnerL), SID,
  -                             {start_recon, bloom, SyncStruct, true}}),
  +                             {start_recon, Method, MySyncStruct, true}}),
               send_local(self(), {shutdown, {ok, build_struct}}),
               Stats;
           art ->
               {AOk, ARStats} = 
                   case Initiator of
  -                    true -> art_recon(SyncStruct, proplists:get_value(art, Params), State);                    
  +                    true -> art_recon(MySyncStruct, Params, State);
                       false ->
  -                        SyncI = art:get_interval(SyncStruct),
  -                        SyncParams = [{art, SyncStruct}],
  -                        send(DestRRPid,
  -                             {continue_recon, comm:make_global(OwnerL), SID,
  -                              {create_struct, Method, SyncI, SyncParams, true}}),
  +                        send(DestRRPid, {continue_recon, comm:make_global(OwnerL), SID,
  +                                         {start_recon, Method, MySyncStruct, true}}),
                           {no, Stats}
                   end,
               send_local(self(), {shutdown, ?IIF(AOk =:= ok, sync_finished, build_struct)}),
  
positive.code:        true         -> NewState
      end;
  
  on({continue, Method, Stage, Struct, Initiator} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      send_local(State#rr_recon_state.dhtNodePid, {get_state, comm:this(), my_range}),
  
negative.code: 
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  -spec build_struct(DBList::db_chunk_enc(), DestI::I, RestI::I, state()) -> state()
            when is_subtype(I, intervals:interval()).
  build_struct(DBList, DestI, RestI,
               State = #rr_recon_state{method = RMethod, struct = Params,
                                       initiator = Initiator, stats = Stats,
                                       dhtNodePid = DhtNodePid}) ->
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
                  {BTime, NTree} = util:tc(merkle_tree, insert_list, [DBList, Params]),
                  {rr_recon_stats:get(build_time, Stats) + BTime, merkle_tree:gen_hash(NTree) };
              false ->
                  ToBuild = ?IIF(RMethod =:= art, ?IIF(Initiator, merkle_tree, art), RMethod),
                  util:tc(fun() -> build_recon_struct(ToBuild, {DestI, DBList}) end)
          end,
      EmptyRest = intervals:is_empty(RestI),
      % bloom may fork more recon processes if un-synced elements remain
      if not EmptyRest ->
             SubSyncI = find_intersection(DestI, RestI),
             case intervals:is_empty(SubSyncI) of
                 false ->
                     Pid = if RMethod =:= bloom -> 
                                  erlang:element(2, fork_recon(State#rr_recon_state{dest_interval = SubSyncI,
                                                                                    struct = Params}));
                              true -> self()
                           end,
                     send_chunk_req(DhtNodePid, Pid, find_intersection(RestI, DestI), SubSyncI,
                                    get_max_items(RMethod));
                 true -> ok
             end;
          true -> ok
      end,
      {NStage, NStats} =
          if EmptyRest orelse RMethod =:= bloom -> {reconciliation, begin_sync(SyncStruct, State)};
             not EmptyRest andalso RMethod =:= merkle_tree -> {build_struct, Stats};
             true -> {reconciliation, Stats}
          end,
      State#rr_recon_state{ stage = NStage,
                            struct = SyncStruct,
                            stats = rr_recon_stats:set([{build_time, BuildTime}], NStats) }.
  
  -spec begin_sync(sync_struct(), state()) -> rr_recon_stats:stats().
  begin_sync(MySyncStruct, State = #rr_recon_state{method = Method,
                                                   struct = Params,
                                                   ownerPid = OwnerL,
                                                   dest_recon_pid = DestReconPid,
                                                   dest_rr_pid = DestRRPid,
                                                   initiator = Initiator,
                                                   stats = Stats }) ->
      ?TRACE("BEGIN SYNC", []),
      SID = rr_recon_stats:get(session_id, Stats),
      case Method of
          merkle_tree -> 
              case Initiator of
                  true -> send(DestReconPid,
                               {check_nodes, comm:this(), [merkle_tree:get_hash(MySyncStruct)]});
                  false ->
                      SyncI = merkle_tree:get_interval(MySyncStruct),
                      SyncParams = [{reconPid, comm:this()}],
                      send(DestRRPid,
                           {continue_recon, comm:make_global(OwnerL), SID,
  