anchor.diff:      is_subtype(State,  state()),
       is_subtype(Stats,  rr_recon_stats:stats()).
   art_recon(Tree, Art, #rr_recon_state{ dest_rr_pid = DestPid,
  -                                      ownerLocalPid = OwnerL,
  -                                      ownerRemotePid = OwnerR,
  +                                      ownerPid = OwnerL,
                                         stats = Stats }) ->
       SID = rr_recon_stats:get(session_id, Stats),
       NStats = case merkle_tree:get_interval(Tree) =:= art:get_interval(Art) of
                    true -> 
                        {ASyncLeafs, Stats2} = art_get_sync_leafs([merkle_tree:get_root(Tree)], Art, Stats, []),
                        ResolveCalled = lists:foldl(fun(X, Acc) ->
  -                                                         Acc + resolve_leaf(X, {DestPid, SID, OwnerL, OwnerR})
  +                                                         Acc + resolve_leaf(X, {DestPid, SID, OwnerL})
                                                    end, 0, ASyncLeafs),
                        rr_recon_stats:inc([{resolve_started, ResolveCalled}], Stats2);
                    false -> Stats
  
positive.code:        #rr_recon_state{ dest_recon_pid = DestReconPid,
                          dest_rr_pid = SrcNode,
                          stats = Stats, 
                          ownerLocalPid = OwnerL,
                          ownerRemotePid = OwnerR,
                          struct = Tree }) ->
      SID = rr_recon_stats:get(session_id, Stats),
      {Req, Res, NStats, RTree} = process_tree_cmp_result(CmpResults, Tree, get_merkle_branch_factor(), Stats),
      Req =/= [] andalso
          comm:send(DestReconPid, {check_nodes, comm:this(), Req}),    
      {Leafs, Resolves} = lists:foldl(fun(Node, {AccL, AccR}) -> 
                                              {LCount, RCount} = resolve_node(Node, {SrcNode, SID, OwnerL, OwnerR}),
                                              {AccL + LCount, AccR + RCount}
                                      end, {0, 0}, Res),
      FStats = rr_recon_stats:inc([{tree_leafsSynced, Leafs}, 
  
negative.code:                 false ->
                      IntParams = [{interval, merkle_tree:get_interval(SyncStruct)}, {reconPid, comm:this()}],
                      comm:send(DestRRPid, 
                                {continue_recon, comm:make_global(OwnerL), SID, 
                                 {continue, merkle_tree, res_shared_interval, IntParams, true}})
              end,
              rr_recon_stats:set(
                [{tree_compareLeft, ?IIF(Initiator, 1, 0)},
                 {tree_size, merkle_tree:size_detail(SyncStruct)}], Stats);
          bloom ->
              comm:send(DestRRPid, {continue_recon, comm:make_global(OwnerL), SID,
                                    {continue, bloom, reconciliation, SyncStruct, true}}),
              comm:send_local(self(), {shutdown, {ok, build_struct}}),
              Stats;
  