anchor.diff:          {[_|_] = RTree, MerkleSyncNew, NStats, MyMaxLeafCount, MyMaxItemsCount} ->
               NStage = reconciliation,
               OtherMaxItemsCount = OtherMaxLeafCount * BucketSize - MaxLeafItemsCountDiff,
  -            % note: we need to use the same P1E for this level's signature
  -            %       comparison as a children's tree has in total!
  -            L = erlang:max(MyMaxLeafCount, OtherMaxLeafCount),
  -            NextSigSizeI =
  -                min_max(
  -                  util:ceil(
  -                    util:log2(erlang:min(1, MyMaxItemsCount + OtherMaxItemsCount)
  -                                  / P1E)), 1, 160),
  -            % exact, but due to problems with precision near 1 not feasible:
  -%%             NextSigSizeL =
  -%%                 min_max(
  -%%                   util:ceil(
  -%%                     util:log2(
  -%%                       % note: see TODO above for P0E precision!
  -%%                       1 / (1 - math:pow(1 - P1E / (2 * BucketSize), 1 / L))
  -%%                     )), 1, 160),
  -
  -            % approx (Puiseux Series of the above):
  -            NextSigSizeL =
  -                min_max(
  -                  util:ceil(
  -                    (math:log(2 * BucketSize * L) - math:log(P1E)) / math:log(2) +
  -                        (1 - L) * P1E / (BucketSize * L * math:log(16))
  -                    ), 1, 160),
  -            ?DBG_ASSERT(NextSigSizeL >= NextSigSizeI),
  -%%             log:pal("P1E: ~p, \tSigSizeI: ~B, \tSigSizeL: ~B~n"
  -%%                     "Buckets: ~B, \tMyMI: ~B, \tOtMI: ~B, \tMyML: ~B, \tOtML: ~B",
  -%%                     [P1E, NextSigSizeL, NextSigSizeI,
  -%%                      BucketSize, MyMaxItemsCount, OtherMaxItemsCount, MyMaxLeafCount, OtherMaxLeafCount]),
  +            {P1E, NextSigSizeI, NextSigSizeL} =
  +                merkle_next_signature_sizes(Params, P1ETotal, MyMaxLeafCount, MyMaxItemsCount,
  +                                            OtherMaxLeafCount, OtherMaxItemsCount),
               Req = merkle_compress_hashlist(RTree, <<>>, NextSigSizeI, NextSigSizeL),
               send(DestReconPid, {?check_nodes, Req, NextSigSizeI, NextSigSizeL - NextSigSizeI})
       end,
  
positive.code:     1;
  calc_signature_size_1_to_n(N, P1E, MaxSize) when P1E > 0 ->
      min_max(util:ceil(util:log2(N / P1E)), 1, MaxSize).
  
  -compile({nowarn_unused_function, {min_max_feeder, 3}}).
  -spec min_max_feeder(X::number(), Min::number(), Max::number())
  
negative.code: on({?check_nodes_response, FlagsBin, OtherMaxLeafCount, MaxLeafItemsCountDiff},
     State = #rr_recon_state{stage = reconciliation,        initiator = true,
                             method = merkle_tree,          merkle_sync = MerkleSync,
                             params = #merkle_params{bucket_size = BucketSize} = Params,
                             struct = Tree,                 stats = Stats,
                             dest_recon_pid = DestReconPid,
                             misc = [{signature_size, {SigSizeI, SigSizeL}},
                                     {p1e, P1ETotal}]}) ->
      case process_tree_cmp_result(FlagsBin, Tree, SigSizeI, SigSizeL, MerkleSync, Stats) of
          {[] = RTree, [] = MerkleSyncNew, NStats, _MyMaxLeafCount, _MyMaxItemsCount} ->
              NStage = reconciliation,
              P1E = P1ETotal,
              NextSigSizeI = SigSizeI,
              NextSigSizeL = SigSizeL,
              ok;
          {[] = RTree, [_|_] = MerkleSyncNew, NStats, _MyMaxLeafCount, _MyMaxItemsCount} ->
              NStage = resolve,
              P1E = P1ETotal,
              NextSigSizeI = SigSizeI,
              NextSigSizeL = SigSizeL,
              % note: we will get a resolve_req message from the other node
  