anchor.diff:      Intersection = intervals:intersection(MyIMapped, SrcIMapped),
       case intervals:is_empty(Intersection) of
           true ->
  -            ?TRACE("SYNC CLIENT - INTERSECTION EMPTY", []),
               comm:send_local(self(), {shutdown, intersection_empty});
           false ->
               MyIntersec = mapInterval_to_range(Intersection, MyInterval, 2),
  
positive.code: 
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  -spec build_recon_struct(Method, DB_Chunk, Args) -> Recon_Struct when
        is_subtype(Method,       method()),
        is_subtype(DB_Chunk,     {intervals:interval(), db_as_list_enc()}),
        is_subtype(Args,         build_args()),
        is_subtype(Recon_Struct, bloom_recon_struct() | merkle_tree:merkle_tree() | art:art()).
  
  build_recon_struct(bloom, {I, DBItems}, {Fpr}) ->
      ElementNum = length(DBItems),
      HFCount = bloom:calc_HF_numEx(ElementNum, Fpr),
      Hfs = ?REP_HFS:new(HFCount),    
  
negative.code: 
  on({get_chunk_response, {RestI, DBList}}, State =
         #ru_recon_state{ recon_stage = build_struct,
                          recon_method = RMethod,        
                          recon_struct = Params,                    
                          sync_round = Round,
                          dhtNodePid = DhtNodePid,
                          sync_master = SyncMaster,
                          stats = Stats }) ->
      MyI = proplists:get_value(interval, Params),
      SyncI = ?IIF(RMethod =:= bloom, mapInterval(MyI, 1), MyI),    
      ToBuild = ?IIF(RMethod =:= art, ?IIF(SyncMaster, merkle_tree, art), RMethod),
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
                  {BTime, NTree} = util:tc(fun() -> add_to_tree(DBList, Params) end),
                  {ru_recon_stats:get(build_time, Stats) + BTime, merkle_tree:gen_hash(NTree) };
              false ->                
                  util:tc(fun() -> build_recon_struct(ToBuild, {SyncI, DBList}) end)
          end,
      EmptyRest = intervals:is_empty(RestI),
      if not EmptyRest ->
              Pid = if RMethod =:= bloom -> {ok, P} = fork_recon(State, Round), P;
                       true -> self()
                    end,
              send_chunk_req(DhtNodePid, Pid, RestI, 
                             mapInterval(RestI, get_interval_quadrant(SyncI)), 
                             get_max_items(RMethod));
          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#ru_recon_state{ recon_stage = NStage, 
                            recon_struct = SyncStruct, 
                            stats = ru_recon_stats:set([{build_time, BuildTime}], NStats) };    
      
  on({get_chunk_response, {RestI, DBList}}, State = 
         #ru_recon_state{ recon_stage = reconciliation,
  