anchor.diff:      merkle_resolve_req_keys_noninit(TL, NHashes, BinKeyList, DestRRPid, NStats,
                                       OwnerL, ToSend1, ToReq1, ToResolve1,
                                       ResolveNonEmpty1, BKLNonEmpty);
  +merkle_resolve_req_keys_noninit([_ | TL], Hashes, BinKeyList, DestRRPid,
  +                                Stats, OwnerL, ToSend, ToReq, ToResolve,
  +                                ResolveNonEmpty, BKLNonEmpty) ->
  +    % already resolved by initiator / in first step or optimised empty BinKeyList
  +    merkle_resolve_req_keys_noninit(TL, Hashes, BinKeyList, DestRRPid, Stats,
  +                                    OwnerL, ToSend, ToReq, ToResolve,
  +                                    ResolveNonEmpty, BKLNonEmpty);
   merkle_resolve_req_keys_noninit([], <<>>, [], DestRRPid, Stats, OwnerL,
                                   ToSend, ToReq, ToResolve, ResolveNonEmpty,
                                   _BKLNonEmpty) ->
  
positive.code:     NodeHash0 = merkle_tree:get_hash(Node),
      <<NodeHash:SigSize/integer-unit:1>> = <<NodeHash0:SigSize>>,
      if Hash =:= NodeHash andalso IsLeafHash =:= IsLeafNode ->
             p_check_node(TK, TN, SigSize, <<FlagsAcc/bitstring, ?recon_ok:2>>,
                          AccN, MerkleSynAcc,
                          MerkleSyncIN, AccMLC);
         (not IsLeafNode) andalso (not IsLeafHash) ->
             NewAccMLC = erlang:max(AccMLC, merkle_tree:get_leaf_count(Node)),
             Childs = merkle_tree:get_childs(Node),
             p_check_node(TK, TN, SigSize, <<FlagsAcc/bitstring, ?recon_fail_cont_inner:2>>,
                          [Childs | AccN], MerkleSynAcc,
                          MerkleSyncIN, NewAccMLC);
         (not IsLeafNode) andalso IsLeafHash ->
             {LeafNodes, FoundHash} =
                 merkle_get_sync_leaves([Node], Hash, SigSize, [], false),
             p_check_node(TK, TN, SigSize, <<FlagsAcc/bitstring, ?recon_fail_stop_inner:2>>,
                          AccN, [{inner, leaf, SigSize, LeafNodes, FoundHash} | MerkleSynAcc],
                          MerkleSyncIN, AccMLC);
         IsLeafNode andalso IsLeafHash ->
             p_check_node(TK, TN, SigSize, <<FlagsAcc/bitstring, ?recon_fail_stop_leaf:2>>,
                          AccN, [{leaf, leaf, SigSize, Node} | MerkleSynAcc],
                          MerkleSyncIN, AccMLC);
         IsLeafNode andalso (not IsLeafHash) ->
             p_check_node(TK, TN, SigSize, <<FlagsAcc/bitstring, ?recon_fail_stop_leaf:2>>,
                          AccN, [{leaf, inner, SigSize, Node} | MerkleSynAcc],
                          MerkleSyncIN, AccMLC)
      end.
  
  
negative.code:         ResolveNonEmpty::boolean())
          -> NewStats::Stats
      when is_subtype(Stats, rr_recon_stats:stats()).
  merkle_resolve_req_keys_init([{leaf, inner, SigSize0, LeafNode, false = _FoundSkipHash} | TL],
                               [ReqKeys | BinKeyList],
                               DestRRPid, Stats, OwnerL, SendKeys, true) ->
      SendKeys1 =
          case ReqKeys of
              [] -> SendKeys;
              [_|_] ->
                  ReqSet = gb_sets:from_list(ReqKeys),
                  {SigSize, _VSize} = align_bitsize(SigSize0, get_min_version_bits()),
                  [Key || {Key, _Version} <- merkle_tree:get_bucket(LeafNode),
                          gb_sets:is_member(compress_key(Key, SigSize),
                                            ReqSet)] ++ SendKeys
          end,
      merkle_resolve_req_keys_init(TL, BinKeyList, DestRRPid, Stats, OwnerL,
                                   SendKeys1, true);
  merkle_resolve_req_keys_init([_ | TL], BinKeyList, DestRRPid, Stats, OwnerL,
                               SendKeys, ResolveNonEmpty) ->
      % already resolved by non-initiator / in first step or optimised empty BinKeyList
      merkle_resolve_req_keys_init(TL, BinKeyList, DestRRPid, Stats, OwnerL,
                                   SendKeys, ResolveNonEmpty);
  merkle_resolve_req_keys_init([], [], DestRRPid, Stats, OwnerL, [_|_] = SendKeys,
  