anchor.diff:                               MySyncAccDRK, MySyncAccDRLCount, OtherSyncAccDRLCount,
                                SyncIN, AccCmp + 1, AccSkip,
                                NextLvlNodesActOUT, HashCmpI_OUT, HashCmpL_IN);
  -       (not IsLeafNode) andalso IsLeafHash andalso Hash =/= none ->
  +       (not IsLeafNode) andalso NonEmptyLeafHash ->
              % inner node here, non-empty leaf there
  -           % don't compare hashes -> this is an exact process based on the tags
  +           % no need to compare hashes - this is an exact process based on the tags
              {MyKVItems, LeafCount} = merkle_tree:get_items([Node]),
              Sync = {MyMaxItemsCount, MyKVItems, LeafCount},
              merkle_check_node(TK, TN, SigSizeI, SigSizeL,
  
positive.code:                   RestTreeAcc, SyncAccSend, SyncAccRcv,
                    MySyncAccDRK, MySyncAccDRLCount, OtherSyncAccDRLCount, AccCmp, AccSkip,
                    NextLvlNodesActIN, HashCmpI_IN, HashCmpL_IN) ->
      case merkle_tree:is_leaf(Node) of
          true  ->
              case merkle_tree:is_empty(Node) of
                  false ->
                      MaxItemsCount = erlang:min(Params#merkle_params.bucket_size,
                                                 MyMaxItemsCount),
                      SyncAccRcv1 =
                          [{MaxItemsCount, merkle_tree:get_bucket(Node), 1} | SyncAccRcv],
                      OtherSyncAccDRLCount1 = OtherSyncAccDRLCount,
                      HashCmpL_OUT = HashCmpL_IN + 1;
                  true ->
                      SyncAccRcv1 = SyncAccRcv,
                      OtherSyncAccDRLCount1 = OtherSyncAccDRLCount + 1,
                      HashCmpL_OUT = HashCmpL_IN
              end;
          false ->
              {MyKVItems, LeafCount} = merkle_tree:get_items([Node]),
              SyncAccRcv1 =
                  [{MyMaxItemsCount, MyKVItems, LeafCount} | SyncAccRcv],
  
negative.code:                              MySyncAccDRK, MySyncAccDRLCount, OtherSyncAccDRLCount,
                               SyncIN, AccCmp + 1, AccSkip,
                               NextLvlNodesActIN, HashCmpI_IN, HashCmpL_IN);
         NonEmptyLeafNode andalso (NonEmptyLeafHash orelse not IsLeafHash) ->
             % non-empty leaf here, non-empty leaf or inner node there
             if NonEmptyLeafHash -> % both non-empty leaf nodes
                    OtherMaxItemsCount1 =
                        erlang:min(Params#merkle_params.bucket_size,
                                   OtherMaxItemsCount),
                    HashCmpL_OUT = HashCmpL_IN + 1;
                true -> % inner node there
                    OtherMaxItemsCount1 = OtherMaxItemsCount,
                    HashCmpL_OUT = HashCmpL_IN
             end,
             SyncAccSend1 =
                 [{OtherMaxItemsCount1, merkle_tree:get_bucket(Node),
                   merkle_tree:get_item_count(Node)} | SyncAccSend],
             merkle_check_node(TK, TN, SigSizeI, SigSizeL,
                               MyMaxItemsCount, OtherMaxItemsCount, Params, Stats,
                               <<FlagsAcc/bitstring, ?recon_fail_stop_leaf:2>>, RestTreeAcc,
                               SyncAccSend1, SyncAccRcv,
                               MySyncAccDRK, MySyncAccDRLCount, OtherSyncAccDRLCount,
                               SyncIN, AccCmp + 1, AccSkip,
                               NextLvlNodesActIN, HashCmpI_IN, HashCmpL_OUT);
         (NonEmptyLeafNode orelse not IsLeafNode) andalso EmptyLeafHash ->
             % non-empty leaf or inner node here, empty leaf there
             % no need to compare hashes - this is an exact process based on the tags
             % -> resolve directly here, i.e. without a trivial sub process
             ResultCode = if not IsLeafNode -> ?recon_fail_stop_inner; % stop_empty_leaf1
                             NonEmptyLeafNode -> ?recon_fail_stop_leaf % stop_empty_leaf2
                          end,
             {MyKVItems, LeafCount} = merkle_tree:get_items([Node]),
             MySyncAccDRK1 = [element(1, X) || X <- MyKVItems] ++ MySyncAccDRK,
             merkle_check_node(TK, TN, SigSizeI, SigSizeL,
                               MyMaxItemsCount, OtherMaxItemsCount, Params, Stats,
                               <<FlagsAcc/bitstring, ResultCode:2>>, RestTreeAcc,
                               SyncAccSend, SyncAccRcv,
                               MySyncAccDRK1, MySyncAccDRLCount + LeafCount,
                               OtherSyncAccDRLCount,
                               SyncIN, AccCmp + 1, AccSkip,
                               NextLvlNodesActIN, HashCmpI_IN, HashCmpL_IN);
         EmptyLeafNode andalso (NonEmptyLeafHash orelse not IsLeafHash) ->
             % empty leaf here, non-empty leaf or inner node there
             % no need to compare hashes - this is an exact process based on the tags
             % -> resolved directly at the other node, i.e. without a trivial sub process
             ResultCode = if not IsLeafHash -> ?recon_fail_stop_inner; % stop_empty_leaf3
                             NonEmptyLeafHash -> ?recon_fail_cont_inner % stop_empty_leaf4
                          end,
             merkle_check_node(TK, TN, SigSizeI, SigSizeL,
                               MyMaxItemsCount, OtherMaxItemsCount, Params, Stats,
                               <<FlagsAcc/bitstring, ResultCode:2>>, RestTreeAcc,
                               SyncAccSend, SyncAccRcv,
                               MySyncAccDRK, MySyncAccDRLCount, OtherSyncAccDRLCount + 1,
                               SyncIN, AccCmp + 1, AccSkip,
                               NextLvlNodesActIN, HashCmpI_IN, HashCmpL_IN)
      end.
  
  %% @doc Processes compare results from merkle_check_node/21 on the initiator.
  