anchor.diff:                          ownerPid = OwnerL,
                           struct = Tree }) ->
       SID = rr_recon_stats:get(session_id, Stats),
  -    {Req, Res, NStats, RTree} = process_tree_cmp_result(
  -                                  CmpResults, Tree,
  -                                  get_merkle_branch_factor(), % this is how we build the tree!
  -                                  Stats),
  +    {Req, ToResolve, NStats0, RTree} =
  +        process_tree_cmp_result(CmpResults, Tree,
  +                                get_merkle_branch_factor(), % this is how we build the tree!
  +                                Stats),
       Req =/= [] andalso
           send(DestReconPid, {check_nodes, Req}),
  -    Resolves = resolve_leaves(Res, SrcNode, SID, OwnerL),
  -    FStats = rr_recon_stats:inc([{tree_leavesSynced, length(Res)},
  -                                 {resolve_started, Resolves}], NStats),
  -    CompLeft = rr_recon_stats:get(tree_compareLeft, FStats),
  -    NewState = State#rr_recon_state{stats = FStats, struct = RTree},
  +    ResolveCount = resolve_leaves(ToResolve, SrcNode, SID, OwnerL),
  +    NStats = rr_recon_stats:inc([{tree_leavesSynced, length(ToResolve)},
  +                                 {resolve_started, ResolveCount}], NStats0),
  +    CompLeft = rr_recon_stats:get(tree_compareLeft, NStats),
  +    NewState = State#rr_recon_state{stats = NStats, struct = RTree},
       if CompLeft =:= 0 ->
              send(DestReconPid, {shutdown, sync_finished_remote}),
              shutdown(sync_finished, NewState);
  
positive.code: % Merkle Tree specific
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  %% @doc Compares the given Hashes from the other node with my merkle_tree nodes.
  %%      Returns the comparison results and the rest nodes to check in a next
  %%      step.
  -spec check_node(Hashes::[merkle_cmp_request()],
                   merkle_tree:merkle_tree() | NodeList)
          -> {[merkle_cmp_result()], RestTree::NodeList, ResolveReq::NodeList}
      when is_subtype(NodeList, [merkle_tree:mt_node()]).
  check_node(L, Tree) ->
      case merkle_tree:is_merkle_tree(Tree) of
          false -> p_check_node(L, Tree, [], [], []);
          true -> p_check_node(L, [merkle_tree:get_root(Tree)], [], [], [])
      end.
  
  %% @doc Helper for check_node/2.
  -spec p_check_node(Hashes::[merkle_cmp_request()], MyNodes::NodeList,
  
negative.code: p_check_node([], [], AccR, AccN, AccRes) ->
      {lists:reverse(AccR), lists:append(lists:reverse(AccN)), AccRes};
  p_check_node([{ToOmit, Hash} | TK], [Node | TN], AccR, AccN, AccRes) ->
      {OmitNodes0, RestNodes} = util:safe_split(ToOmit - 1, TN),
      ToResolve = merkle_get_sync_leaves([Node | OmitNodes0], Hash, AccRes),
      p_check_node(TK, RestNodes, AccR, AccN, ToResolve);
  p_check_node([Hash | TK], [Node | TN], AccR, AccN, AccRes) ->
      IsLeaf = merkle_tree:is_leaf(Node),
      case merkle_tree:get_hash(Node) of
          Hash when IsLeaf ->
              p_check_node(TK, TN, [?ok_leaf | AccR], AccN, AccRes);
          Hash when not IsLeaf ->
              p_check_node(TK, TN, [?ok_inner | AccR], AccN, AccRes);
          NodeHash when IsLeaf ->
              p_check_node(TK, TN, [{?fail_leaf, NodeHash} | AccR], AccN, AccRes);
          _    when not IsLeaf ->
              Childs = merkle_tree:get_childs(Node),
              p_check_node(TK, TN, [?fail_inner | AccR], [Childs | AccN], AccRes)
      end.
  
  %% @doc Processes compare results from check_node/2 on the initiator.
  -spec process_tree_cmp_result([merkle_cmp_result()],
                                merkle_tree:merkle_tree() | RestTree,
                                BranchSize::pos_integer(), Stats)
  