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:          bloom    = ?required(bloom_recon_struct, bloom)    :: ?REP_BLOOM:bloom_filter()         
          }).
  
  -type internal_params() :: {reconPid, comm:mypid()} |
                             {art, art:art()}.
  
  -type sync_struct() :: #bloom_recon_struct{} |
                         merkle_tree:merkle_tree() |
                         art:art().
  -type parameters() :: sync_struct() |
                        [internal_params()] |
                        [merkle_tree:mt_node()].
  -type recon_dest() :: ?RT:key() | random.
  
  
negative.code:        true         -> NewState
      end;
  
  on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = reconciliation,     initiator = true,
                             method = art,               struct = SyncStruct}) ->
      ?TRACE1(_Msg, State),
      % no need to map keys since the other node's bloom filter was created with
      % keys mapped to our interval
      DBList = [encodeBlob(KeyX, VersionX) || {KeyX, VersionX} <- DBList0],
      MySyncI = art:get_interval(SyncStruct),
      build_struct(DBList, MySyncI, RestI, State);
  
  on({continue, Method, Stage, Struct, Initiator} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      send_local(State#rr_recon_state.dhtNodePid, {get_state, comm:this(), my_range}),
  