anchor.diff:           dest_recon_pid     = undefined                                 :: comm:mypid() | undefined, %dest recon process pid
            method             = undefined                                 :: method() | undefined,
            dest_interval      = intervals:empty()                         :: intervals:interval(),
  -         struct             = {}                                        :: parameters() | {},
  +         params             = {}                                        :: parameters() | {}, % parameters from the other node
  +         struct             = {}                                        :: sync_struct() | {}, % my recon structure
            stage              = req_shared_interval                       :: stage(),
            initiator          = false                                     :: boolean(),
            stats              = rr_recon_stats:new()                      :: rr_recon_stats:stats()
  
positive.code: -spec build_struct(DBList::db_chunk_enc(), DestI::intervals:non_empty_interval(),
                     RestI::intervals:interval(), state()) -> state() | kill.
  build_struct(DBList, DestI, RestI,
               State = #rr_recon_state{method = RMethod, struct = Params,
                                       initiator = Initiator, stats = Stats,
                                       dhtNodePid = DhtNodePid, stage = Stage}) ->
      ?ASSERT(not intervals:is_empty(DestI)),
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
                  {BTime, NTree} = util:tc(merkle_tree, insert_list, [DBList, Params]),
                  {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,
      Stats1 = rr_recon_stats:inc([{build_time, BuildTime}], Stats),
      NewState = State#rr_recon_state{struct = SyncStruct, stats = Stats1},
      EmptyRest = intervals:is_empty(RestI),
  
negative.code:                    Reconcile = Initiator andalso (Stage =:= reconciliation),
                     if RMethod =:= bloom -> 
                            ForkState = State#rr_recon_state{dest_interval = SubSyncI,
                                                             params = Params},
                            {ok, Pid} = fork_recon(ForkState),
                            send_chunk_req(DhtNodePid, Pid, MySubSyncI, SubSyncI,
                                           get_max_items(RMethod), Reconcile);
  